kevin/linux
1
Fork 0
Code
77933d7276
linux/sound/oss/emu10k1/cardwi.c
Linus Torvalds 1da177e4c3 Linux-2.6.12-rc2 
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!
2005-04-16 15:20:36 -07:00

374 lines
9.3 KiB
C
Raw Blame History

/*
**********************************************************************
* cardwi.c - PCM input HAL for emu10k1 driver
* Copyright 1999, 2000 Creative Labs, Inc.
*
**********************************************************************
*
* Date Author Summary of changes
* ---- ------ ------------------
* October 20, 1999 Bertrand Lee base code release
*
**********************************************************************
*
* 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.
*
**********************************************************************
*/
#include <linux/poll.h>
#include "hwaccess.h"
#include "timer.h"
#include "recmgr.h"
#include "audio.h"
#include "cardwi.h"
/**
* query_format - returns a valid sound format
*
* This function will return a valid sound format as close
* to the requested one as possible.
*/
static void query_format(int recsrc, struct wave_format *wave_fmt)
{
switch (recsrc) {
case WAVERECORD_AC97:
if ((wave_fmt->channels != 1) && (wave_fmt->channels != 2))
wave_fmt->channels = 2;
if (wave_fmt->samplingrate >= (0xBB80 + 0xAC44) / 2)
wave_fmt->samplingrate = 0xBB80;
else if (wave_fmt->samplingrate >= (0xAC44 + 0x7D00) / 2)
wave_fmt->samplingrate = 0xAC44;
else if (wave_fmt->samplingrate >= (0x7D00 + 0x5DC0) / 2)
wave_fmt->samplingrate = 0x7D00;
else if (wave_fmt->samplingrate >= (0x5DC0 + 0x5622) / 2)
wave_fmt->samplingrate = 0x5DC0;
else if (wave_fmt->samplingrate >= (0x5622 + 0x3E80) / 2)
wave_fmt->samplingrate = 0x5622;
else if (wave_fmt->samplingrate >= (0x3E80 + 0x2B11) / 2)
wave_fmt->samplingrate = 0x3E80;
else if (wave_fmt->samplingrate >= (0x2B11 + 0x1F40) / 2)
wave_fmt->samplingrate = 0x2B11;
else
wave_fmt->samplingrate = 0x1F40;
switch (wave_fmt->id) {
case AFMT_S16_LE:
wave_fmt->bitsperchannel = 16;
break;
case AFMT_U8:
wave_fmt->bitsperchannel = 8;
break;
default:
wave_fmt->id = AFMT_S16_LE;
wave_fmt->bitsperchannel = 16;
break;
}
break;
/* these can't be changed from the original values */
case WAVERECORD_MIC:
case WAVERECORD_FX:
break;
default:
BUG();
break;
}
wave_fmt->bytesperchannel = wave_fmt->bitsperchannel >> 3;
wave_fmt->bytespersample = wave_fmt->channels * wave_fmt->bytesperchannel;
wave_fmt->bytespersec = wave_fmt->bytespersample * wave_fmt->samplingrate;
wave_fmt->bytespervoicesample = wave_fmt->bytespersample;
}
static int alloc_buffer(struct emu10k1_card *card, struct wavein_buffer *buffer)
{
buffer->addr = pci_alloc_consistent(card->pci_dev, buffer->size * buffer->cov,
&buffer->dma_handle);
if (buffer->addr == NULL)
return -1;
return 0;
}
static void free_buffer(struct emu10k1_card *card, struct wavein_buffer *buffer)
{
if (buffer->addr != NULL)
pci_free_consistent(card->pci_dev, buffer->size * buffer->cov,
buffer->addr, buffer->dma_handle);
}
int emu10k1_wavein_open(struct emu10k1_wavedevice *wave_dev)
{
struct emu10k1_card *card = wave_dev->card;
struct wiinst *wiinst = wave_dev->wiinst;
struct wiinst **wiinst_tmp = NULL;
u16 delay;
unsigned long flags;
DPF(2, "emu10k1_wavein_open()\n");
switch (wiinst->recsrc) {
case WAVERECORD_AC97:
wiinst_tmp = &card->wavein.ac97;
break;
case WAVERECORD_MIC:
wiinst_tmp = &card->wavein.mic;
break;
case WAVERECORD_FX:
wiinst_tmp = &card->wavein.fx;
break;
default:
BUG();
break;
}
spin_lock_irqsave(&card->lock, flags);
if (*wiinst_tmp != NULL) {
spin_unlock_irqrestore(&card->lock, flags);
return -1;
}
*wiinst_tmp = wiinst;
spin_unlock_irqrestore(&card->lock, flags);
/* handle 8 bit recording */
if (wiinst->format.bytesperchannel == 1) {
if (wiinst->buffer.size > 0x8000) {
wiinst->buffer.size = 0x8000;
wiinst->buffer.sizeregval = 0x1f;
} else
wiinst->buffer.sizeregval += 4;
wiinst->buffer.cov = 2;
} else
wiinst->buffer.cov = 1;
if (alloc_buffer(card, &wiinst->buffer) < 0) {
ERROR();
return -1;
}
emu10k1_set_record_src(card, wiinst);
emu10k1_reset_record(card, &wiinst->buffer);
wiinst->buffer.hw_pos = 0;
wiinst->buffer.pos = 0;
wiinst->buffer.bytestocopy = 0;
delay = (48000 * wiinst->buffer.fragment_size) / wiinst->format.bytespersec;
emu10k1_timer_install(card, &wiinst->timer, delay / 2);
wiinst->state = WAVE_STATE_OPEN;
return 0;
}
void emu10k1_wavein_close(struct emu10k1_wavedevice *wave_dev)
{
struct emu10k1_card *card = wave_dev->card;
struct wiinst *wiinst = wave_dev->wiinst;
unsigned long flags;
DPF(2, "emu10k1_wavein_close()\n");
emu10k1_wavein_stop(wave_dev);
emu10k1_timer_uninstall(card, &wiinst->timer);
free_buffer(card, &wiinst->buffer);
spin_lock_irqsave(&card->lock, flags);
switch (wave_dev->wiinst->recsrc) {
case WAVERECORD_AC97:
card->wavein.ac97 = NULL;
break;
case WAVERECORD_MIC:
card->wavein.mic = NULL;
break;
case WAVERECORD_FX:
card->wavein.fx = NULL;
break;
default:
BUG();
break;
}
spin_unlock_irqrestore(&card->lock, flags);
wiinst->state = WAVE_STATE_CLOSED;
}
void emu10k1_wavein_start(struct emu10k1_wavedevice *wave_dev)
{
struct emu10k1_card *card = wave_dev->card;
struct wiinst *wiinst = wave_dev->wiinst;
DPF(2, "emu10k1_wavein_start()\n");
emu10k1_start_record(card, &wiinst->buffer);
emu10k1_timer_enable(wave_dev->card, &wiinst->timer);
wiinst->state |= WAVE_STATE_STARTED;
}
void emu10k1_wavein_stop(struct emu10k1_wavedevice *wave_dev)
{
struct emu10k1_card *card = wave_dev->card;
struct wiinst *wiinst = wave_dev->wiinst;
DPF(2, "emu10k1_wavein_stop()\n");
if (!(wiinst->state & WAVE_STATE_STARTED))
return;
emu10k1_timer_disable(card, &wiinst->timer);
emu10k1_stop_record(card, &wiinst->buffer);
wiinst->state &= ~WAVE_STATE_STARTED;
}
int emu10k1_wavein_setformat(struct emu10k1_wavedevice *wave_dev, struct wave_format *format)
{
struct emu10k1_card *card = wave_dev->card;
struct wiinst *wiinst = wave_dev->wiinst;
u16 delay;
DPF(2, "emu10k1_wavein_setformat()\n");
if (wiinst->state & WAVE_STATE_STARTED)
return -1;
query_format(wiinst->recsrc, format);
if ((wiinst->format.samplingrate != format->samplingrate)
|| (wiinst->format.bitsperchannel != format->bitsperchannel)
|| (wiinst->format.channels != format->channels)) {
wiinst->format = *format;
if (wiinst->state == WAVE_STATE_CLOSED)
return 0;
wiinst->buffer.size *= wiinst->buffer.cov;
if (wiinst->format.bytesperchannel == 1) {
wiinst->buffer.cov = 2;
wiinst->buffer.size /= wiinst->buffer.cov;
} else
wiinst->buffer.cov = 1;
emu10k1_timer_uninstall(card, &wiinst->timer);
delay = (48000 * wiinst->buffer.fragment_size) / wiinst->format.bytespersec;
emu10k1_timer_install(card, &wiinst->timer, delay / 2);
}
return 0;
}
void emu10k1_wavein_getxfersize(struct wiinst *wiinst, u32 * size)
{
struct wavein_buffer *buffer = &wiinst->buffer;
*size = buffer->bytestocopy;
if (wiinst->mmapped)
return;
if (*size > buffer->size) {
*size = buffer->size;
buffer->pos = buffer->hw_pos;
buffer->bytestocopy = buffer->size;
DPF(1, "buffer overrun\n");
}
}
static void copy_block(u8 __user *dst, u8 * src, u32 str, u32 len, u8 cov)
{
if (cov == 1)
__copy_to_user(dst, src + str, len);
else {
u8 byte;
u32 i;
src += 1 + 2 * str;
for (i = 0; i < len; i++) {
byte = src[2 * i] ^ 0x80;
__copy_to_user(dst + i, &byte, 1);
}
}
}
void emu10k1_wavein_xferdata(struct wiinst *wiinst, u8 __user *data, u32 * size)
{
struct wavein_buffer *buffer = &wiinst->buffer;
u32 sizetocopy, sizetocopy_now, start;
unsigned long flags;
sizetocopy = min_t(u32, buffer->size, *size);
*size = sizetocopy;
if (!sizetocopy)
return;
spin_lock_irqsave(&wiinst->lock, flags);
start = buffer->pos;
buffer->pos += sizetocopy;
buffer->pos %= buffer->size;
buffer->bytestocopy -= sizetocopy;
sizetocopy_now = buffer->size - start;
spin_unlock_irqrestore(&wiinst->lock, flags);
if (sizetocopy > sizetocopy_now) {
sizetocopy -= sizetocopy_now;
copy_block(data, buffer->addr, start, sizetocopy_now, buffer->cov);
copy_block(data + sizetocopy_now, buffer->addr, 0, sizetocopy, buffer->cov);
} else {
copy_block(data, buffer->addr, start, sizetocopy, buffer->cov);
}
}
void emu10k1_wavein_update(struct emu10k1_card *card, struct wiinst *wiinst)
{
u32 hw_pos;
u32 diff;
/* There is no actual start yet */
if (!(wiinst->state & WAVE_STATE_STARTED)) {
hw_pos = wiinst->buffer.hw_pos;
} else {
/* hw_pos in byte units */
hw_pos = sblive_readptr(card, wiinst->buffer.idxreg, 0) / wiinst->buffer.cov;
}
diff = (wiinst->buffer.size + hw_pos - wiinst->buffer.hw_pos) % wiinst->buffer.size;
wiinst->total_recorded += diff;
wiinst->buffer.bytestocopy += diff;
wiinst->buffer.hw_pos = hw_pos;
}
View Git Blame Copy Permalink