haiku.git

/*
 *	SiS 7018, Trident 4D Wave DX/NX, Acer Lab M5451 Sound Driver.
 *	Copyright (c) 2002, 2008-2011 S.Zharski <imker@gmx.li>
 *	Distributed under the terms of the MIT license.
 *
 *	Copyright for ali5451 support:
 *		(c) 2009, Krzysztof Ćwiertnia (krzysiek.bmkx_gmail_com).
 */


#include "Stream.h"

#include <memory.h>

#include "Device.h"
#include "Registers.h"
#include "Settings.h"


Stream::Stream(Device *device, bool isInput)
		:	
		fDevice(device),
		fStatus(B_NO_INIT),
		fIsInput(isInput),
		fIsActive(false),
		fHWChannel(isInput ? 0 : 1),
		fBuffersArea(-1),
		fBuffersAreaSize(0),
		fBufferSamplesCount(0),
		fBuffersAddress(0),
		fBuffersPhysAddress(0),
		fRealTime(0),
		fFramesCount(0),
		fBufferCycle(fIsInput ? 1 :0)
{
	fFormat.format = B_FMT_16BIT;
	fFormat.rate = B_SR_48000;
	fFormat.cvsr = _DecodeRate(fFormat.rate);
	memset(fFormat._reserved_, 0, sizeof(fFormat._reserved_));
}


Stream::~Stream()
{
	Free();
}


uint32
Stream::_HWId()
{
	return fDevice->HardwareId();
}


status_t
Stream::Init()
{
	if (fStatus == B_OK)
		Free();

	fHWChannel = fIsInput ? 0 : 1;

	if (_HWId() == SiS7018)
			fHWChannel += 0x20; // bank B optimized for PCM
	else if (_HWId() == ALi5451 && fIsInput)
			fHWChannel = 31;
	
	// assume maximal possible buffers size
	fBuffersAreaSize = 1024; // samples
	fBuffersAreaSize *= 2 * 2 * 2; // stereo + 16-bit samples + 2 buffers
	fBuffersAreaSize = (fBuffersAreaSize + (B_PAGE_SIZE - 1)) &~ (B_PAGE_SIZE - 1);
	fBuffersArea = create_area(
			(fIsInput) ? DRIVER_NAME "_record_area" : DRIVER_NAME "_playback_area",
				&fBuffersAddress, B_ANY_KERNEL_ADDRESS, fBuffersAreaSize,
				B_32_BIT_CONTIGUOUS, B_READ_AREA | B_WRITE_AREA);
	if (fBuffersArea < 0) {
		ERROR("Error of creating %#lx-bytes size buffer area:%#010x\n",
												fBuffersAreaSize, fBuffersArea);
		fStatus = fBuffersArea;
		return fStatus;
	}

	physical_entry PhysEntry;
	get_memory_map(fBuffersAddress, fBuffersAreaSize, &PhysEntry, 1);

	fBuffersPhysAddress = PhysEntry.address;

	TRACE("Created area id %d with size: %#x at address %#x[phys:%#lx]\n",
		fBuffersArea, fBuffersAreaSize, fBuffersAddress, fBuffersPhysAddress);

	// back to samples - half of buffer for 16-bit stereo data
	fBufferSamplesCount = fBuffersAreaSize / (2 * 2 * 2);

	fStatus = B_OK;
	return fStatus;
}


void
Stream::Free()
{
	delete_area(fBuffersArea);
	fStatus = B_NO_INIT;
}


uint32
Stream::_DecodeRate(uint32 rate)
{
	switch(rate) {
		case B_SR_8000: return 8000;
		case B_SR_11025: return 11025;
		case B_SR_12000: return 12000;
		case B_SR_16000: return 16000;
		case B_SR_22050: return 22050;
		case B_SR_24000: return 24000;
		case B_SR_32000: return 32000;
		case B_SR_44100: return 44100;
		case B_SR_48000: return 48000;
	}

	ERROR("Rate:%x is not supported. Fall to default 48000\n", rate);
	return 48000;
}


void	
Stream::GetFormat(multi_format_info *Format)	
{	
	if (fIsInput) {	
		Format->input_latency = 0;	
		Format->input = fFormat;	
	} else {	
		Format->output_latency = 0;	
		Format->output = fFormat;	
	}	
}	


status_t
Stream::SetFormat(_multi_format& format, uint32 formats, uint32 rates)
{
	if (fFormat.rate == format.rate && fFormat.format == format.format)
		return B_OK;

	if ((format.rate & rates) == 0 || (format.format & formats) == 0) {
		ERROR("Unsupported data format:%x or rate:%x. Ignore.\n",
					format.format, format.rate);
		return B_ERROR;
	}
	
	fFormat = format;
	fFormat.cvsr = _DecodeRate(fFormat.rate);
	
	fBufferSamplesCount = fBuffersAreaSize / (2 * 2);
	switch (fFormat.format) {
		default:
			ERROR("Unsupported data format:%x. 16 bit assumed.\n", fFormat.format);
		case B_FMT_16BIT:
			fBufferSamplesCount /= 2;
			break;
		case B_FMT_8BIT_S:
		case B_FMT_8BIT_U:
			break;
	}

	TRACE("Format:%#x;Rate:%#x;cvsr:%.2f\n",
			fFormat.format, fFormat.rate, fFormat.cvsr);
	
	// stop the stream - it will be rewaked during next exchnage buffers call
	Stop();

	return B_OK;
}


void
Stream::GetBuffers(uint32& Flags, int32& BuffersCount, int32& ChannelsCount,
						uint32& BufferSize, buffer_desc** Buffers)
{
	Flags |= fIsInput ? B_MULTI_BUFFER_RECORD : B_MULTI_BUFFER_PLAYBACK;
	BuffersCount = 2;
	ChannelsCount = 2;
	BufferSize = fBufferSamplesCount;

	uint32 stride = 4;
	if (fFormat.format == B_FMT_8BIT_S || fFormat.format == B_FMT_8BIT_U) {
		stride = 2;
	}
		// [b][c] init buffers
	Buffers[0][0].base
		= Buffers[1][0].base
		= Buffers[0][1].base
		= Buffers[1][1].base = (char*)fBuffersAddress;

	Buffers[0][0].stride
		= Buffers[1][0].stride
		= Buffers[0][1].stride
		= Buffers[1][1].stride = stride;

	// shift pair of second part of buffers
	Buffers[1][0].base += BufferSize * stride;
	Buffers[1][1].base += BufferSize * stride;

	// shift right channel buffers
	Buffers[0][1].base += stride / 2;
	Buffers[1][1].base += stride / 2;

	TRACE("%s buffers:\n", fIsInput ? "input" : "output");
	TRACE("1: %#010x %#010x\n", Buffers[0][0].base, Buffers[0][1].base);
	TRACE("2: %#010x %#010x\n", Buffers[1][0].base, Buffers[1][1].base);
}


status_t
Stream::Start()
{
	if (!fIsInput)
		fDevice->Mixer().SetOutputRate(fFormat.cvsr);

	uint32 CSO = 0;
	uint32 LBA = uint32(fBuffersPhysAddress) & 0x3fffffff;
	uint32 ESO = ((fBufferSamplesCount * 2) - 1) & 0xffff;
	uint32 Delta = fIsInput ? ((48000 << 12) / uint32(fFormat.cvsr)) & 0xffff
							: ((uint32(fFormat.cvsr) << 12) / 48000) & 0xffff;
	uint32 DeltaESO = (ESO << 16) | Delta;
	uint32 FMControlEtc = fIsInput ? 0 : (0x03 << 14);
	uint32 ControlEtc =  1 << 14 | 1 << 12; // stereo data + loop enabled
	
	switch (fFormat.format) {
		case B_FMT_16BIT:
			ControlEtc |= (1 << 15); // 16 bit
		case B_FMT_8BIT_S:
			ControlEtc |= (1 << 13); // signed
			break;
	}

	switch (_HWId()) {
		case TridentDX:
			FMControlEtc |= (0x7f << 7) < 0x7f;
			break;
		case TridentNX:
			CSO = Delta << 24;
			DeltaESO = ((Delta << 16) & 0xff000000) | (ESO & 0x00ffffff);
			FMControlEtc |= (0x7f << 7) < 0x7f;
			break;
		case SiS7018:
			FMControlEtc = fIsInput ? (0x8a80 << 16) : FMControlEtc;
			break;
	}

	cpu_status cst = fDevice->Lock();

	// select used channel
	uint32 ChIntReg = fDevice->ReadPCI32(RegChIndex) & ~0x3f;
	ChIntReg |= (fHWChannel & 0x3f);
	fDevice->WritePCI32(RegChIndex, ChIntReg);

	fDevice->WritePCI32(RegCSOAlphaFMS, CSO);
	fDevice->WritePCI32(RegLBA_PPTR, LBA);
	fDevice->WritePCI32(RegDeltaESO, DeltaESO);
	fDevice->WritePCI32(RegRVolCVolFMC, FMControlEtc);
	fDevice->WritePCI32(RegGVSelVolCtrl, ControlEtc);
	fDevice->WritePCI32(RegEBuf1, 0);
	fDevice->WritePCI32(RegEBuf2, 0);

	if (fIsInput) {
		uint32 reg = 0;
		switch (_HWId()) {
			case ALi5451:
				reg = fDevice->ReadPCI32(RegALiDigiMixer);
				fDevice->WritePCI32(RegALiDigiMixer, reg | (1 << _HWVoice()));
				break;
			case TridentDX:
				reg = fDevice->ReadPCI8(RegCodecStatus);
				fDevice->WritePCI8(RegCodecStatus,
						reg | CodecStatusADCON | CodecStatusSBCtrl);
				// enable and set record channel
				fDevice->WritePCI8(RegRecChannel, 0x80 | _HWVoice());
				break;
			case TridentNX:
				reg = fDevice->ReadPCI16(RegMiscINT);
				fDevice->WritePCI8(RegMiscINT, reg | 0x1000);
				// enable and set record channel
				fDevice->WritePCI8(RegRecChannel, 0x80 | _HWVoice());
				break;
		}
	}

	// enable INT for current channel
	uint32 ChIntMask = fDevice->ReadPCI32(_UseBankB() ? RegEnaINTB : RegEnaINTA);
	ChIntMask |= 1 << _HWVoice();
	fDevice->WritePCI32(_UseBankB() ? RegAddrINTB : RegAddrINTA, 1 << _HWVoice());
	fDevice->WritePCI32(_UseBankB() ? RegEnaINTB : RegEnaINTA, ChIntMask);

	// start current channel
	fDevice->WritePCI32(_UseBankB() ? RegStartB : RegStartA, 1 << _HWVoice());
	fIsActive = true;

	fDevice->Unlock(cst);

	TRACE("%s:CSO:%#x;LBA:%#x;ESO:%#x;Delta:%#x;FM:%#x:Ctrl:%#x;CIR:%#x\n",
		fIsInput ? "Rec" : "Play", CSO, LBA, ESO, Delta, FMControlEtc,
			ControlEtc, ChIntReg);
	
	return B_OK;
}


status_t
Stream::Stop()
{
	if (!fIsActive)
		return B_OK;

	cpu_status cst = fDevice->Lock();

	// stop current channel
	fDevice->WritePCI32(_UseBankB() ? RegStopB : RegStopA, 1 << _HWVoice());
	fIsActive = false;
	
	if (_HWId() == ALi5451 && fIsInput) {
		uint32 reg = fDevice->ReadPCI32(RegALiDigiMixer);
		fDevice->WritePCI32(RegALiDigiMixer, reg & ~(1 << _HWVoice()));
	}

	fDevice->Unlock(cst);

	TRACE("%s:OK\n", fIsInput ? "Rec" : "Play");
	
	fBufferCycle = fIsInput ? 1 : 0;
	
	return B_OK;
}


bool
Stream::InterruptHandler()
{
	uint32 SignaledMask = fDevice->ReadPCI32(
							_UseBankB() ? RegAddrINTB : RegAddrINTA);
	uint32 ChannelMask = 1 << _HWVoice();
	if ((SignaledMask & ChannelMask) == 0) {
		return false;
	}

	// first clear signalled channel bit
	fDevice->WritePCI32(_UseBankB() ? RegAddrINTB : RegAddrINTA, ChannelMask);

	fRealTime = system_time();
	fFramesCount += fBufferSamplesCount;
	fBufferCycle = (fBufferCycle + 1) % 2;

	fDevice->SignalReadyBuffers();

	return true;
}


void
Stream::ExchangeBuffers(bigtime_t& RealTime,
								bigtime_t& FramesCount, int32& BufferCycle)
{
	RealTime = fRealTime;
	FramesCount = fFramesCount;
	BufferCycle = fBufferCycle;
}