patch-2.4.0-test7 linux/drivers/sound/emu10k1/cardwi.c

• Lines: 578
• Date: Mon Aug 14 08:32:48 2000
• Orig file: v2.4.0-test6/linux/drivers/sound/emu10k1/cardwi.c
• Orig date: Wed Apr 26 16:34:08 2000

diff -u --recursive --new-file v2.4.0-test6/linux/drivers/sound/emu10k1/cardwi.c linux/drivers/sound/emu10k1/cardwi.c
@@ -1,4 +1,3 @@
-
 /*
  **********************************************************************
  *     cardwi.c - PCM input HAL for emu10k1 driver
@@ -30,7 +29,9 @@
  **********************************************************************
  */
 
+#include <linux/poll.h>
 #include "hwaccess.h"
+#include "timer.h"
 #include "recmgr.h"
 #include "audio.h"
 #include "cardwi.h"
@@ -41,7 +42,7 @@
 	switch (recsrc) {
 	case WAVERECORD_AC97:
 
-		if ((wave_fmt->channels != 2) && (wave_fmt->channels != 1))
+		if ((wave_fmt->channels != 1) && (wave_fmt->channels != 2))
 			wave_fmt->channels = 2;
 
 		if (wave_fmt->samplingrate >= (0xBB80 + 0xAC44) / 2)
@@ -61,110 +62,41 @@
 		else
 			wave_fmt->samplingrate = 0x1F40;
 
-		if ((wave_fmt->bitsperchannel != 16) && (wave_fmt->bitsperchannel != 8))
+		if ((wave_fmt->bitsperchannel != 8) && (wave_fmt->bitsperchannel != 16))
 			wave_fmt->bitsperchannel = 16;
 
 		break;
 
+	/* these can't be changed from the original values */
 	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:
+		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;
+
 	return;
 }
 
-static int alloc_recbuffer(struct wave_in *wave_in, u32 * bufsize, u8 ** buffer)
+static int alloc_buffer(struct emu10k1_card *card, struct wavein_buffer *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);
+	if ((buffer->addr = pci_alloc_consistent(card->pci_dev, buffer->size * buffer->cov, &buffer->dma_handle)) == NULL)
+		return -1;
 
-	/* 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;
+	return 0;
 }
 
-static int get_recbuffer(struct emu10k1_card *card, struct wave_in *wave_in, u32 * size)
+static void free_buffer(struct emu10k1_card *card, struct wavein_buffer *buffer)
 {
-	u8 *buffer;
+	if (buffer->addr != NULL)
+		pci_free_consistent(card->pci_dev, buffer->size * buffer->cov, buffer->addr, buffer->dma_handle);
 
-	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;
 }
 
@@ -172,301 +104,264 @@
 {
 	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;
+	struct wiinst **wiinst_tmp = NULL;
+	u32 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;
+		wiinst_tmp = &card->wavein.ac97;
 		break;
 	case WAVERECORD_MIC:
-		wave_in_tmp = &card->wavein->mic;
+		wiinst_tmp = &card->wavein.mic;
 		break;
 	case WAVERECORD_FX:
-		wave_in_tmp = &card->wavein->fx;
+		wiinst_tmp = &card->wavein.fx;
 		break;
 	default:
+		BUG();
 		break;
 	}
 
 	spin_lock_irqsave(&card->lock, flags);
-	if (*wave_in_tmp != NULL) {
+	if (*wiinst_tmp != NULL) {
 		spin_unlock_irqrestore(&card->lock, flags);
-		kfree(wave_in);
-		return CTSTATUS_ERROR;
+		return -1;
 	}
 
-	*wave_in_tmp = wave_in;
+	*wiinst_tmp = wiinst;
 	spin_unlock_irqrestore(&card->lock, flags);
 
-	wiinst->wave_in = wave_in;
+	/* 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 ((wave_in->rec_ptr = (struct record *) kmalloc(sizeof(struct record), GFP_KERNEL)) == NULL) {
+	if (alloc_buffer(card, &wiinst->buffer) < 0) {
 		ERROR();
 		emu10k1_wavein_close(wave_dev);
-		return CTSTATUS_ERROR;
+		return -1;
 	}
 
-	buffsize = wiinst->fragment_size * wiinst->numfrags;
+	emu10k1_set_record_src(card, wiinst);
 
-	if (get_recbuffer(card, wave_in, &buffsize) != CTSTATUS_SUCCESS) {
-		ERROR();
-		emu10k1_wavein_close(wave_dev);
-		return CTSTATUS_ERROR;
-	}
+	delay = (48000 * wiinst->buffer.fragment_size) / wiinst->format.bytespersec;
 
-	wiinst->fragment_size = buffsize / wiinst->numfrags;
+	emu10k1_timer_install(card, &wiinst->timer, delay / 2);
 
-	/* 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;
+	wiinst->state = WAVE_STATE_OPEN;
 
-	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;
+	return 0;
 }
 
 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;
+	struct wiinst *wiinst = wave_dev->wiinst;
 	unsigned long flags;
 
-	if (wave_in->state != CARDWAVE_STATE_STOPPED)
-		emu10k1_wavein_stop(wave_dev);
+	DPF(2, "emu10k1_wavein_close()\n");
 
-	if (wave_in->timer != NULL)
-		emu10k1_timer_uninstall(card, wave_in->timer);
+	emu10k1_wavein_stop(wave_dev);
 
-	if (wave_in->memhandle != NULL)
-		dealloc_recbuffer(wave_in);
+	emu10k1_timer_uninstall(card, &wiinst->timer);
 
-	if (wave_in->rec_ptr != NULL)
-		kfree(wave_in->rec_ptr);
+	free_buffer(card, &wiinst->buffer);
 
 	spin_lock_irqsave(&card->lock, flags);
 	switch (wave_dev->wiinst->recsrc) {
 	case WAVERECORD_AC97:
-		card->wavein->ac97 = NULL;
+		card->wavein.ac97 = NULL;
 		break;
 	case WAVERECORD_MIC:
-		card->wavein->mic = NULL;
+		card->wavein.mic = NULL;
 		break;
 	case WAVERECORD_FX:
-		card->wavein->fx = NULL;
+		card->wavein.fx = NULL;
 		break;
 	default:
+		BUG();
 		break;
 	}
 	spin_unlock_irqrestore(&card->lock, flags);
 
-	kfree(wave_in);
-	wave_dev->wiinst->wave_in = NULL;
+	wiinst->state = WAVE_STATE_CLOSED;
 
 	return;
 }
 
 void emu10k1_wavein_start(struct emu10k1_wavedevice *wave_dev)
 {
-	struct wave_in *wave_in = wave_dev->wiinst->wave_in;
+	struct emu10k1_card *card = wave_dev->card;
+	struct wiinst *wiinst = wave_dev->wiinst;
 
 	DPF(2, "emu10k1_wavein_start()\n");
 
-	if (wave_in->state == CARDWAVE_STATE_STARTED)
-		return;
+	emu10k1_start_record(card, &wiinst->buffer);
+	emu10k1_timer_enable(wave_dev->card, &wiinst->timer);
 
-	emu10k1_start_record(wave_in->rec_ptr);
-	wave_in->state = CARDWAVE_STATE_STARTED;
+	wiinst->buffer.hw_pos = 0;
+	wiinst->buffer.pos = 0;
+	wiinst->buffer.bytestocopy = 0;
 
-	emu10k1_timer_enable(wave_dev->card, wave_in->timer);
+	wiinst->state |= WAVE_STATE_STARTED;
 
 	return;
 }
 
 void emu10k1_wavein_stop(struct emu10k1_wavedevice *wave_dev)
 {
-	struct wave_in *wave_in = wave_dev->wiinst->wave_in;
+	struct emu10k1_card *card = wave_dev->card;
+	struct wiinst *wiinst = wave_dev->wiinst;
 
 	DPF(2, "emu10k1_wavein_stop()\n");
 
-	emu10k1_stop_record(wave_in->rec_ptr);
-	emu10k1_timer_disable(wave_dev->card, wave_in->timer);
+	if (!(wiinst->state & WAVE_STATE_STARTED))
+		return;
+
+	emu10k1_timer_disable(card, &wiinst->timer);
+	emu10k1_stop_record(card, &wiinst->buffer);
 
-	wave_in->rec_ptr->recpos = 0;
-	wave_in->state = CARDWAVE_STATE_STOPPED;
+	wiinst->state &= ~WAVE_STATE_STARTED;
 
 	return;
 }
 
-int emu10k1_wavein_setformat(struct emu10k1_wavedevice *wave_dev)
+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;
-	struct wave_in *wave_in = wiinst->wave_in;
-	u32 bytespersec, delay;
+	u32 delay;
 
 	DPF(2, "emu10k1_wavein_setformat()\n");
 
-	query_format(wiinst->recsrc, &wiinst->wave_fmt);
+	if (wiinst->state & WAVE_STATE_STARTED)
+		return -1;
 
-	if (!wave_in)
-		return CTSTATUS_SUCCESS;
+	query_format(wiinst->recsrc, format);
 
-	if (wave_in->state == CARDWAVE_STATE_STARTED) {
-		wiinst->wave_fmt = wave_in->wave_fmt;
-		return CTSTATUS_SUCCESS;
-	}
+	if ((wiinst->format.samplingrate != format->samplingrate)
+	    || (wiinst->format.bitsperchannel != format->bitsperchannel)
+	    || (wiinst->format.channels != format->channels)) {
 
-	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)) {
+		wiinst->format = *format;
 
-		emu10k1_timer_uninstall(card, wave_in->timer);
+		if (wiinst->state == WAVE_STATE_CLOSED)
+			return 0;
 
-		wave_in->wave_fmt = wiinst->wave_fmt;
+		wiinst->buffer.size *= wiinst->buffer.cov;
 
-		bytespersec = wave_in->wave_fmt.channels * (wave_in->wave_fmt.bitsperchannel >> 3) * (wave_in->wave_fmt.samplingrate);
-		delay = (48000 * wave_in->callbacksize) / bytespersec;
+		if (wiinst->format.bytesperchannel == 1) {
+			wiinst->buffer.cov = 2;
+			wiinst->buffer.size /= wiinst->buffer.cov;
+		} else
+			wiinst->buffer.cov = 1;
 
-		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;
-		}
+		emu10k1_timer_uninstall(card, &wiinst->timer);
+
+		delay = (48000 * wiinst->buffer.fragment_size) / wiinst->format.bytespersec;
+
+		emu10k1_timer_install(card, &wiinst->timer, delay / 2);
 	}
 
-	return CTSTATUS_SUCCESS;
+	return 0;
 }
 
-void emu10k1_wavein_getxfersize(struct wave_in *wave_in, u32 * size, u32 * curpos)
+void emu10k1_wavein_getxfersize(struct wiinst *wiinst, u32 * size)
 {
-	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;
+	struct wavein_buffer *buffer = &wiinst->buffer;
 
-	/* Recpos is the actual position in user buffer and play buffer */
-	if (*curpos < rec_ptr->recpos)
-		*size += rec_ptr->recbufsize;
+	*size = buffer->bytestocopy;
 
-	if (!rec_ptr->is_16bit)
-		*size >>= 1;
+	if (*size > buffer->size) {
+		*size = buffer->size;
+		buffer->pos = buffer->hw_pos;
+		buffer->bytestocopy = buffer->size;
+		DPF(1, "buffer overrun\n");
+	}
 
 	return;
 }
 
-static void copy_s16_to_u8(u8 * dstbuf, s16 * srcbuf, u32 size)
+static void copy_block(u8 *dst, u8 * src, u32 str, u32 len, u8 cov)
 {
-	u16 sample;
-	u8 byte;
-
-	while (size--) {
-		sample = (*srcbuf) + 32767;
-		byte = (u8) (sample >> 8);
-		copy_to_user(dstbuf, &byte, 1);
-		dstbuf++;
-		srcbuf++;
+	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);
+		}
 	}
+
+	return;
 }
 
-/* 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;
+	struct wavein_buffer *buffer = &wiinst->buffer;
 	u32 sizetocopy, sizetocopy_now, start;
 	unsigned long flags;
 
-	sizetocopy = min(rec_ptr->recbufsize * (rec_ptr->is_16bit + 1) / 2, *size);
+	sizetocopy = min(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;
 
-	sizetocopy_now = (rec_ptr->recbufsize - rec_ptr->recpos) * (rec_ptr->is_16bit + 1) / 2;
-
-	start = rec_ptr->recpos;
+	spin_unlock_irqrestore(&wiinst->lock, flags);
 
 	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);
-		}
+		copy_block(data, buffer->addr, start, sizetocopy_now, buffer->cov);
+		copy_block(data + sizetocopy_now, buffer->addr, 0, sizetocopy, buffer->cov);
 	} 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);
+		copy_block(data, buffer->addr, start, sizetocopy, buffer->cov);
 	}
 
 	return;
 }
 
-/* get the specified control value of the wave device. */
-
-int emu10k1_wavein_getcontrol(struct wave_in *wave_in, u32 ctrlid, u32 * value)
+void emu10k1_wavein_update(struct emu10k1_card *card, struct wiinst *wiinst)
 {
-	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;
+	u32 hw_pos;
+	u32 diff;
 
-	default:
-		return CTSTATUS_ERROR;
+	/* 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;
 	}
 
-	return CTSTATUS_SUCCESS;
+	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;
+
+	return;
 }