patch-2.3.99-pre6 linux/drivers/sound/emu10k1/cardwi.c
Next file: linux/drivers/sound/emu10k1/cardwi.h
Previous file: linux/drivers/sound/emu10k1/cardmo.h
Back to the patch index
Back to the overall index
- Lines: 473
- Date:
Fri Apr 21 16:08:45 2000
- Orig file:
v2.3.99-pre5/linux/drivers/sound/emu10k1/cardwi.c
- Orig date:
Wed Dec 31 16:00:00 1969
diff -u --recursive --new-file v2.3.99-pre5/linux/drivers/sound/emu10k1/cardwi.c linux/drivers/sound/emu10k1/cardwi.c
@@ -0,0 +1,472 @@
+
+/*
+ **********************************************************************
+ * 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 "hwaccess.h"
+#include "recmgr.h"
+#include "audio.h"
+#include "cardwi.h"
+
+void query_format(int recsrc, struct wave_format *wave_fmt)
+{
+
+ switch (recsrc) {
+ case WAVERECORD_AC97:
+
+ if ((wave_fmt->channels != 2) && (wave_fmt->channels != 1))
+ 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;
+
+ if ((wave_fmt->bitsperchannel != 16) && (wave_fmt->bitsperchannel != 8))
+ wave_fmt->bitsperchannel = 16;
+
+ break;
+
+ case WAVERECORD_MIC:
+ wave_fmt->channels = 1;
+ wave_fmt->samplingrate = 0x1F40;
+ wave_fmt->bitsperchannel = 8;
+ break;
+
+ case WAVERECORD_FX:
+ wave_fmt->channels = 2;
+ wave_fmt->samplingrate = 0xBB80;
+ wave_fmt->bitsperchannel = 16;
+ break;
+
+ default:
+ break;
+ }
+
+ return;
+}
+
+static int alloc_recbuffer(struct wave_in *wave_in, u32 * bufsize, u8 ** buffer)
+{
+ u32 reqsize;
+ int i, j;
+ u32 size[4];
+
+ /* NOTE: record buffer size only can be certain sizes. If the requested
+ * size is not a nice size, use the smaller nearest size. The minimum size is 1k. */
+ if (!wave_in->rec_ptr->is_16bit)
+ *bufsize <<= 1;
+
+ if (*bufsize >= 0x10000) {
+ *bufsize = reqsize = 0x10000;
+ wave_in->rec_ptr->bufsize = 31;
+ } else {
+ reqsize = 0;
+ size[0] = 384;
+ size[1] = 448;
+ size[2] = 512;
+ size[3] = 640;
+
+ for (i = 0; i < 8; i++)
+ for (j = 0; j < 4; j++)
+ if (*bufsize >= size[j]) {
+ reqsize = size[j];
+ size[j] = size[j] * 2;
+ wave_in->rec_ptr->bufsize = i * 4 + j + 1;
+ } else
+ goto exitloop;
+ exitloop:
+ if (reqsize == 0) {
+ reqsize = 384;
+ wave_in->rec_ptr->bufsize = 1;
+ }
+
+ *bufsize = reqsize;
+ }
+
+ DPD(2, "bufsizereg: %x\n", wave_in->rec_ptr->bufsize);
+
+ /* Recording buffer must be continuous and page-aligned */
+ if ((wave_in->memhandle = emu10k1_alloc_memphysical(reqsize)) == NULL)
+ return CTSTATUS_ERROR;
+
+ DPD(2, "recbufsize: %x\n", *bufsize);
+
+ *buffer = (u8 *) wave_in->memhandle->virtaddx;
+
+ return CTSTATUS_SUCCESS;
+}
+
+static int get_recbuffer(struct emu10k1_card *card, struct wave_in *wave_in, u32 * size)
+{
+ u8 *buffer;
+
+ wave_in->rec_ptr->card = card;
+ wave_in->rec_ptr->recpos = 0;
+ wave_in->rec_ptr->samplingrate = wave_in->wave_fmt.samplingrate;
+ wave_in->rec_ptr->is_stereo = (wave_in->wave_fmt.channels == 2) ? 1 : 0;
+ wave_in->rec_ptr->is_16bit = (wave_in->wave_fmt.bitsperchannel == 16) ? 1 : 0;
+
+ /* Allocate buffer here */
+ if (alloc_recbuffer(wave_in, size, &buffer) != CTSTATUS_SUCCESS) {
+ ERROR();
+ return CTSTATUS_ERROR;
+ }
+
+ /* recbufsize contains actual record buffer size */
+ /* for 8 bit samples the size is twice the requested */
+ /* value since we only make use of one in every two bytes */
+ wave_in->rec_ptr->recbufsize = *size;
+ wave_in->rec_ptr->recbuffer = buffer;
+ wave_in->rec_ptr->busaddx = wave_in->memhandle->busaddx;
+
+ return CTSTATUS_SUCCESS;
+}
+
+static void dealloc_recbuffer(struct wave_in *wave_in)
+{
+ emu10k1_free_memphysical(wave_in->memhandle);
+ return;
+}
+
+int emu10k1_wavein_open(struct emu10k1_wavedevice *wave_dev)
+{
+ struct emu10k1_card *card = wave_dev->card;
+ struct wiinst *wiinst = wave_dev->wiinst;
+ struct wave_in *wave_in;
+ struct wave_in **wave_in_tmp = NULL;
+ u32 buffsize, bytespersec, delay;
+ unsigned long flags;
+
+ DPF(2, "emu10k1_wavein_open()\n");
+
+ if ((wave_in = (struct wave_in *) kmalloc(sizeof(struct wave_in), GFP_KERNEL)) == NULL) {
+ ERROR();
+ return CTSTATUS_ERROR;
+ }
+
+ wave_in->state = CARDWAVE_STATE_STOPPED;
+ wave_in->wave_fmt = wiinst->wave_fmt;
+ wave_in->memhandle = NULL;
+ wave_in->timer = NULL;
+
+ switch (wiinst->recsrc) {
+ case WAVERECORD_AC97:
+ wave_in_tmp = &card->wavein->ac97;
+ break;
+ case WAVERECORD_MIC:
+ wave_in_tmp = &card->wavein->mic;
+ break;
+ case WAVERECORD_FX:
+ wave_in_tmp = &card->wavein->fx;
+ break;
+ default:
+ break;
+ }
+
+ spin_lock_irqsave(&card->lock, flags);
+ if (*wave_in_tmp != NULL) {
+ spin_unlock_irqrestore(&card->lock, flags);
+ kfree(wave_in);
+ return CTSTATUS_ERROR;
+ }
+
+ *wave_in_tmp = wave_in;
+ spin_unlock_irqrestore(&card->lock, flags);
+
+ wiinst->wave_in = wave_in;
+
+ if ((wave_in->rec_ptr = (struct record *) kmalloc(sizeof(struct record), GFP_KERNEL)) == NULL) {
+ ERROR();
+ emu10k1_wavein_close(wave_dev);
+ return CTSTATUS_ERROR;
+ }
+
+ buffsize = wiinst->fragment_size * wiinst->numfrags;
+
+ if (get_recbuffer(card, wave_in, &buffsize) != CTSTATUS_SUCCESS) {
+ ERROR();
+ emu10k1_wavein_close(wave_dev);
+ return CTSTATUS_ERROR;
+ }
+
+ wiinst->fragment_size = buffsize / wiinst->numfrags;
+
+ /* This callback size returned is the size in the play buffer.
+ * For 8-bit samples, callbacksize of user buffer should be
+ * half of the callbacksize in play buffer. */
+ if (wave_in->wave_fmt.bitsperchannel == 8)
+ wiinst->fragment_size >>= 1;
+
+ wave_in->callbacksize = wiinst->fragment_size;
+
+ emu10k1_set_record_src(wave_in->rec_ptr, wiinst->recsrc);
+
+ bytespersec = wave_in->wave_fmt.channels * (wave_in->wave_fmt.bitsperchannel >> 3) * (wave_in->wave_fmt.samplingrate);
+ delay = (48000 * wave_in->callbacksize) / bytespersec;
+
+ if ((wave_in->timer = emu10k1_timer_install(card, emu10k1_wavein_bh, (unsigned long) wave_dev, delay / 2)) == NULL) {
+ ERROR();
+ emu10k1_wavein_close(wave_dev);
+ return CTSTATUS_ERROR;
+ }
+
+ return CTSTATUS_SUCCESS;
+}
+
+void emu10k1_wavein_close(struct emu10k1_wavedevice *wave_dev)
+{
+ struct emu10k1_card *card = wave_dev->card;
+ struct wave_in *wave_in = wave_dev->wiinst->wave_in;
+ unsigned long flags;
+
+ if (wave_in->state != CARDWAVE_STATE_STOPPED)
+ emu10k1_wavein_stop(wave_dev);
+
+ if (wave_in->timer != NULL)
+ emu10k1_timer_uninstall(card, wave_in->timer);
+
+ if (wave_in->memhandle != NULL)
+ dealloc_recbuffer(wave_in);
+
+ if (wave_in->rec_ptr != NULL)
+ kfree(wave_in->rec_ptr);
+
+ 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:
+ break;
+ }
+ spin_unlock_irqrestore(&card->lock, flags);
+
+ kfree(wave_in);
+ wave_dev->wiinst->wave_in = NULL;
+
+ return;
+}
+
+void emu10k1_wavein_start(struct emu10k1_wavedevice *wave_dev)
+{
+ struct wave_in *wave_in = wave_dev->wiinst->wave_in;
+
+ DPF(2, "emu10k1_wavein_start()\n");
+
+ if (wave_in->state == CARDWAVE_STATE_STARTED)
+ return;
+
+ emu10k1_start_record(wave_in->rec_ptr);
+ wave_in->state = CARDWAVE_STATE_STARTED;
+
+ emu10k1_timer_enable(wave_dev->card, wave_in->timer);
+
+ return;
+}
+
+void emu10k1_wavein_stop(struct emu10k1_wavedevice *wave_dev)
+{
+ struct wave_in *wave_in = wave_dev->wiinst->wave_in;
+
+ DPF(2, "emu10k1_wavein_stop()\n");
+
+ emu10k1_stop_record(wave_in->rec_ptr);
+ emu10k1_timer_disable(wave_dev->card, wave_in->timer);
+
+ wave_in->rec_ptr->recpos = 0;
+ wave_in->state = CARDWAVE_STATE_STOPPED;
+
+ return;
+}
+
+int emu10k1_wavein_setformat(struct emu10k1_wavedevice *wave_dev)
+{
+ struct emu10k1_card *card = wave_dev->card;
+ struct wiinst *wiinst = wave_dev->wiinst;
+ struct wave_in *wave_in = wiinst->wave_in;
+ u32 bytespersec, delay;
+
+ DPF(2, "emu10k1_wavein_setformat()\n");
+
+ query_format(wiinst->recsrc, &wiinst->wave_fmt);
+
+ if (!wave_in)
+ return CTSTATUS_SUCCESS;
+
+ if (wave_in->state == CARDWAVE_STATE_STARTED) {
+ wiinst->wave_fmt = wave_in->wave_fmt;
+ return CTSTATUS_SUCCESS;
+ }
+
+ if ((wave_in->wave_fmt.samplingrate != wiinst->wave_fmt.samplingrate)
+ || (wave_in->wave_fmt.bitsperchannel != wiinst->wave_fmt.bitsperchannel)
+ || (wave_in->wave_fmt.channels != wiinst->wave_fmt.channels)) {
+
+ emu10k1_timer_uninstall(card, wave_in->timer);
+
+ wave_in->wave_fmt = wiinst->wave_fmt;
+
+ bytespersec = wave_in->wave_fmt.channels * (wave_in->wave_fmt.bitsperchannel >> 3) * (wave_in->wave_fmt.samplingrate);
+ delay = (48000 * wave_in->callbacksize) / bytespersec;
+
+ if ((wave_in->timer = emu10k1_timer_install(card, emu10k1_wavein_bh, (unsigned long) wave_dev, delay / 2)) == NULL) {
+ ERROR();
+ emu10k1_wavein_close(wave_dev);
+ return CTSTATUS_ERROR;
+ }
+ }
+
+ return CTSTATUS_SUCCESS;
+}
+
+void emu10k1_wavein_getxfersize(struct wave_in *wave_in, u32 * size, u32 * curpos)
+{
+ struct record *rec_ptr = wave_in->rec_ptr;
+
+ /* Get position of current address, this is in no. of bytes in play buffer */
+ emu10k1_wavein_getcontrol(wave_in, WAVECURPOS, curpos);
+
+ *size = *curpos - rec_ptr->recpos;
+
+ /* Recpos is the actual position in user buffer and play buffer */
+ if (*curpos < rec_ptr->recpos)
+ *size += rec_ptr->recbufsize;
+
+ if (!rec_ptr->is_16bit)
+ *size >>= 1;
+
+ return;
+}
+
+static void copy_s16_to_u8(u8 * dstbuf, s16 * srcbuf, u32 size)
+{
+ u16 sample;
+ u8 byte;
+
+ while (size--) {
+ sample = (*srcbuf) + 32767;
+ byte = (u8) (sample >> 8);
+ copy_to_user(dstbuf, &byte, 1);
+ dstbuf++;
+ srcbuf++;
+ }
+}
+
+/* transfer the data from the wave device. */
+void emu10k1_wavein_xferdata(struct wiinst *wiinst, u8 * data, u32 * size)
+{
+ struct wave_in *wave_in = wiinst->wave_in;
+ struct record *rec_ptr = wave_in->rec_ptr;
+ u32 sizetocopy, sizetocopy_now, start;
+ unsigned long flags;
+
+ sizetocopy = min(rec_ptr->recbufsize * (rec_ptr->is_16bit + 1) / 2, *size);
+ *size = sizetocopy;
+
+ if (!sizetocopy)
+ return;
+
+ spin_lock_irqsave(&wiinst->lock, flags);
+
+ sizetocopy_now = (rec_ptr->recbufsize - rec_ptr->recpos) * (rec_ptr->is_16bit + 1) / 2;
+
+ start = rec_ptr->recpos;
+
+ if (sizetocopy > sizetocopy_now) {
+ sizetocopy -= sizetocopy_now;
+ rec_ptr->recpos = sizetocopy * 2 / (rec_ptr->is_16bit + 1);
+
+ spin_unlock_irqrestore(&wiinst->lock, flags);
+
+ if (rec_ptr->is_16bit) {
+ copy_to_user(data, rec_ptr->recbuffer + start, sizetocopy_now);
+ copy_to_user(data + sizetocopy_now, rec_ptr->recbuffer, sizetocopy);
+ } else {
+ copy_s16_to_u8(data, (s16 *) (rec_ptr->recbuffer + start), sizetocopy_now);
+ copy_s16_to_u8(data + sizetocopy_now, (s16 *) rec_ptr->recbuffer, sizetocopy);
+ }
+ } else {
+ if (sizetocopy == sizetocopy_now)
+ rec_ptr->recpos = 0;
+ else
+ rec_ptr->recpos += sizetocopy * 2 / (rec_ptr->is_16bit + 1);
+
+ spin_unlock_irqrestore(&wiinst->lock, flags);
+
+ if (rec_ptr->is_16bit)
+ copy_to_user(data, rec_ptr->recbuffer + start, sizetocopy);
+ else
+ copy_s16_to_u8(data, (s16 *) (rec_ptr->recbuffer + start), sizetocopy);
+ }
+
+ return;
+}
+
+/* get the specified control value of the wave device. */
+
+int emu10k1_wavein_getcontrol(struct wave_in *wave_in, u32 ctrlid, u32 * value)
+{
+ switch (ctrlid) {
+ case WAVECURPOS:
+ /* There is no actual start yet */
+ if (wave_in->state == CARDWAVE_STATE_STOPPED) {
+ *value = 0;
+ } else {
+ /* value is in byte units */
+ *value = sblive_readptr(wave_in->rec_ptr->card, wave_in->rec_ptr->bufidxreg, 0);
+ }
+
+ break;
+
+ default:
+ return CTSTATUS_ERROR;
+ }
+
+ return CTSTATUS_SUCCESS;
+}
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)