#include "Device.h"
#include <string.h>
#include "Settings.h"
#include "Registers.h"
Device::Device(Device::Info &DeviceInfo, pci_info &PCIInfo)
:
fStatus(B_ERROR),
fPCIInfo(PCIInfo),
fInfo(DeviceInfo),
fIOBase(0),
fInterruptsNest(0),
fBuffersReadySem(-1),
fMixer(this),
fPlaybackStream(this, false),
fRecordStream(this, true)
{
B_INITIALIZE_SPINLOCK(&fHWSpinlock);
fStatus = _ReserveDeviceOnBus(true);
if (fStatus != B_OK)
return;
uint32 cmdRegister = gPCI->read_pci_config(PCIInfo.bus,
PCIInfo.device, PCIInfo.function, PCI_command, 2);
TRACE("cmdRegister:%#010x\n", cmdRegister);
cmdRegister |= PCI_command_io | PCI_command_memory | PCI_command_master;
gPCI->write_pci_config(PCIInfo.bus, PCIInfo.device,
PCIInfo.function, PCI_command, 2, cmdRegister);
fIOBase = PCIInfo.u.h0.base_registers[0];
TRACE("fIOBase:%#010x\n", fIOBase);
fStatus = B_OK;
}
Device::~Device()
{
fMixer.Free();
_ReserveDeviceOnBus(false);
if (fBuffersReadySem > B_OK) {
delete_sem(fBuffersReadySem);
}
}
void
Device::_ResetCard(uint32 resetMask, uint32 releaseMask)
{
gPCI->write_pci_config(fPCIInfo.bus, fPCIInfo.device,
fPCIInfo.function, 0x40, 4, 0);
uint32 cmdReg = gPCI->read_pci_config(fPCIInfo.bus, fPCIInfo.device,
fPCIInfo.function, 0x44, 4);
gPCI->write_pci_config(fPCIInfo.bus, fPCIInfo.device,
fPCIInfo.function, 0x44, 4, cmdReg & 0xffff0000);
snooze(100);
cmdReg = gPCI->read_pci_config(fPCIInfo.bus, fPCIInfo.device,
fPCIInfo.function, 0x44, 4);
gPCI->write_pci_config(fPCIInfo.bus, fPCIInfo.device,
fPCIInfo.function, 0x44, 4, cmdReg | resetMask);
snooze(100);
cmdReg = gPCI->read_pci_config(fPCIInfo.bus, fPCIInfo.device,
fPCIInfo.function, 0x44, 4);
gPCI->write_pci_config(fPCIInfo.bus, fPCIInfo.device,
fPCIInfo.function, 0x44, 4, cmdReg & ~releaseMask);
snooze(100);
}
status_t
Device::Setup()
{
cpu_status cp = 0;
uint32 channelsIndex = ChIndexMidEna | ChIndexEndEna;
switch (HardwareId()) {
case SiS7018:
_ResetCard(0x000c0000, 0x00040000);
cp = Lock();
WritePCI32(RegSiSCodecGPIO, 0x00000000);
WritePCI32(RegSiSCodecStatus, SiSCodecResetOff);
channelsIndex |= ChIndexSiSEnaB;
Unlock(cp);
break;
case ALi5451:
_ResetCard(0x000c0000, 0x00040000);
cp = Lock();
WritePCI32(RegALiDigiMixer, ALiDigiMixerPCMIn);
WritePCI32(RegALiVolumeA, 0);
Unlock(cp);
break;
case TridentNX:
_ResetCard(0x00010000, 0x00010000);
cp = Lock();
WritePCI32(RegNXCodecStatus, NXCodecStatusDAC1ON);
Unlock(cp);
break;
case TridentDX:
_ResetCard(0x00040000, 0x00040000);
cp = Lock();
WritePCI32(RegCodecStatus, CodecStatusDACON);
Unlock(cp);
break;
}
WritePCI32(RegStopA, 0xffffffff);
WritePCI32(RegStopB, 0xffffffff);
WritePCI32(RegEnaINTA, 0x00000000);
WritePCI32(RegEnaINTB, 0x00000000);
WritePCI32(RegChIndex, channelsIndex);
fRecordStream.Init();
fPlaybackStream.Init();
fBuffersReadySem = create_sem(0, DRIVER_NAME "_buffers_ready");
fMixer.Init();
return B_OK;
}
status_t
Device::Open(uint32 flags)
{
TRACE("flags:%x\n", flags);
if (atomic_add(&fInterruptsNest, 1) == 0) {
install_io_interrupt_handler(fPCIInfo.u.h0.interrupt_line,
InterruptHandler, this, 0);
TRACE("Interrupt handler installed at line %d.\n",
fPCIInfo.u.h0.interrupt_line);
}
status_t status = fRecordStream.Start();
if (status != B_OK) {
ERROR("Error of starting record stream:%#010x\n", status);
}
status = fPlaybackStream.Start();
if (status != B_OK) {
ERROR("Error of starting playback stream:%#010x\n", status);
}
return B_OK;
}
status_t
Device::Close()
{
TRACE("closed!\n");
status_t status = fPlaybackStream.Stop();
if (status != B_OK) {
ERROR("Error of stopping playback stream:%#010x\n", status);
}
status = fRecordStream.Stop();
if (status != B_OK) {
ERROR("Error of stopping record stream:%#010x\n", status);
}
if (atomic_add(&fInterruptsNest, -1) == 1) {
remove_io_interrupt_handler(fPCIInfo.u.h0.interrupt_line,
InterruptHandler, this);
TRACE("Interrupt handler at line %d uninstalled.\n",
fPCIInfo.u.h0.interrupt_line);
}
return B_OK;
}
status_t
Device::Free()
{
TRACE("freed\n");
return B_OK;
}
status_t
Device::Read(uint8 *buffer, size_t *numBytes)
{
*numBytes = 0;
return B_IO_ERROR;
}
status_t
Device::Write(const uint8 *buffer, size_t *numBytes)
{
*numBytes = 0;
return B_IO_ERROR;
}
status_t
Device::Control(uint32 op, void *buffer, size_t length)
{
switch (op) {
case B_MULTI_GET_DESCRIPTION:
return _MultiGetDescription((multi_description*)buffer);
case B_MULTI_GET_EVENT_INFO:
TRACE(("B_MULTI_GET_EVENT_INFO\n"));
return B_ERROR;
case B_MULTI_SET_EVENT_INFO:
TRACE(("B_MULTI_SET_EVENT_INFO\n"));
return B_ERROR;
case B_MULTI_GET_EVENT:
TRACE(("B_MULTI_GET_EVENT\n"));
return B_ERROR;
case B_MULTI_GET_ENABLED_CHANNELS:
return _MultiGetEnabledChannels((multi_channel_enable*)buffer);
case B_MULTI_SET_ENABLED_CHANNELS:
return _MultiSetEnabledChannels((multi_channel_enable*)buffer);
case B_MULTI_GET_GLOBAL_FORMAT:
return _MultiGetGlobalFormat((multi_format_info*)buffer);
case B_MULTI_SET_GLOBAL_FORMAT:
return _MultiSetGlobalFormat((multi_format_info*)buffer);
case B_MULTI_GET_CHANNEL_FORMATS:
TRACE(("B_MULTI_GET_CHANNEL_FORMATS\n"));
return B_ERROR;
case B_MULTI_SET_CHANNEL_FORMATS:
TRACE(("B_MULTI_SET_CHANNEL_FORMATS\n"));
return B_ERROR;
case B_MULTI_GET_MIX:
return _MultiGetMix((multi_mix_value_info *)buffer);
case B_MULTI_SET_MIX:
return _MultiSetMix((multi_mix_value_info *)buffer);
case B_MULTI_LIST_MIX_CHANNELS:
TRACE(("B_MULTI_LIST_MIX_CHANNELS\n"));
return B_ERROR;
case B_MULTI_LIST_MIX_CONTROLS:
return _MultiListMixControls((multi_mix_control_info*)buffer);
case B_MULTI_LIST_MIX_CONNECTIONS:
TRACE(("B_MULTI_LIST_MIX_CONNECTIONS\n"));
return B_ERROR;
case B_MULTI_GET_BUFFERS:
return _MultiGetBuffers((multi_buffer_list*)buffer);
case B_MULTI_SET_BUFFERS:
TRACE(("B_MULTI_SET_BUFFERS\n"));
return B_ERROR;
case B_MULTI_SET_START_TIME:
TRACE(("B_MULTI_SET_START_TIME\n"));
return B_ERROR;
case B_MULTI_BUFFER_EXCHANGE:
return _MultiBufferExchange((multi_buffer_info*)buffer);
case B_MULTI_BUFFER_FORCE_STOP:
TRACE(("B_MULTI_BUFFER_FORCE_STOP\n"));
return B_ERROR;
default:
ERROR("Unhandled IOCTL catched: %#010x\n", op);
}
return B_DEV_INVALID_IOCTL;
}
status_t
Device::_MultiGetDescription(multi_description *multiDescription)
{
multi_channel_info channel_descriptions[] = {
{ 0, B_MULTI_OUTPUT_CHANNEL, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS, 0 },
{ 1, B_MULTI_OUTPUT_CHANNEL, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS, 0 },
{ 2, B_MULTI_INPUT_CHANNEL, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS, 0 },
{ 3, B_MULTI_INPUT_CHANNEL, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS, 0 },
{ 4, B_MULTI_OUTPUT_BUS, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS,
B_CHANNEL_MINI_JACK_STEREO },
{ 5, B_MULTI_OUTPUT_BUS, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS,
B_CHANNEL_MINI_JACK_STEREO },
{ 6, B_MULTI_INPUT_BUS, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS,
B_CHANNEL_MINI_JACK_STEREO },
{ 7, B_MULTI_INPUT_BUS, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS,
B_CHANNEL_MINI_JACK_STEREO },
};
multi_description Description;
if (user_memcpy(&Description,
multiDescription, sizeof(multi_description)) != B_OK)
return B_BAD_ADDRESS;
Description.interface_version = B_CURRENT_INTERFACE_VERSION;
Description.interface_minimum = B_CURRENT_INTERFACE_VERSION;
strlcpy(Description.friendly_name, fInfo.Name(),
sizeof(Description.friendly_name));
strlcpy(Description.vendor_info, "Haiku.Inc.",
sizeof(Description.vendor_info));
Description.output_channel_count = 2;
Description.input_channel_count = 2;
Description.output_bus_channel_count = 2;
Description.input_bus_channel_count = 2;
Description.aux_bus_channel_count = 0;
Description.output_rates = fMixer.OutputRates();
Description.input_rates = fMixer.InputRates();
Description.output_formats = fMixer.OutputFormats();
Description.input_formats = fMixer.InputFormats();
Description.min_cvsr_rate = 0;
Description.max_cvsr_rate = 0;
Description.lock_sources = B_MULTI_LOCK_INTERNAL;
Description.timecode_sources = 0;
Description.interface_flags
= B_MULTI_INTERFACE_PLAYBACK | B_MULTI_INTERFACE_RECORD;
Description.start_latency = 3000;
Description.control_panel[0] = '\0';
if (user_memcpy(multiDescription,
&Description, sizeof(multi_description)) != B_OK)
return B_BAD_ADDRESS;
if (Description.request_channel_count
>= (int)(B_COUNT_OF(channel_descriptions))) {
if (user_memcpy(multiDescription->channels,
&channel_descriptions, sizeof(channel_descriptions)) != B_OK)
return B_BAD_ADDRESS;
}
return B_OK;
}
status_t
Device::_MultiGetEnabledChannels(multi_channel_enable *Enable)
{
B_SET_CHANNEL(Enable->enable_bits, 0, true);
B_SET_CHANNEL(Enable->enable_bits, 1, true);
B_SET_CHANNEL(Enable->enable_bits, 2, true);
B_SET_CHANNEL(Enable->enable_bits, 3, true);
Enable->lock_source = B_MULTI_LOCK_INTERNAL;
return B_OK;
}
status_t
Device::_MultiSetEnabledChannels(multi_channel_enable *Enable)
{
TRACE("0:%s\n", B_TEST_CHANNEL(Enable->enable_bits, 0) ? "en" : "dis");
TRACE("1:%s\n", B_TEST_CHANNEL(Enable->enable_bits, 1) ? "en" : "dis");
TRACE("2:%s\n", B_TEST_CHANNEL(Enable->enable_bits, 2) ? "en" : "dis");
TRACE("3:%s\n", B_TEST_CHANNEL(Enable->enable_bits, 3) ? "en" : "dis");
return B_OK;
}
status_t
Device::_MultiGetGlobalFormat(multi_format_info *Format)
{
fPlaybackStream.GetFormat(Format);
fRecordStream.GetFormat(Format);
return B_OK;
}
status_t
Device::_MultiSetGlobalFormat(multi_format_info *Format)
{
status_t status = fPlaybackStream.SetFormat(Format->output,
fMixer.OutputFormats(), fMixer.OutputRates());
if (status != B_OK)
return status;
return fRecordStream.SetFormat(Format->input,
fMixer.InputFormats(), fMixer.InputRates());
}
status_t
Device::_MultiListMixControls(multi_mix_control_info* Info)
{
return fMixer.ListMixControls(Info);
}
status_t
Device::_MultiGetMix(multi_mix_value_info *Info)
{
return fMixer.GetMix(Info);
}
status_t
Device::_MultiSetMix(multi_mix_value_info *Info)
{
return fMixer.SetMix(Info);
}
status_t
Device::_MultiGetBuffers(multi_buffer_list* List)
{
fPlaybackStream.GetBuffers(List->flags, List->return_playback_buffers,
List->return_playback_channels, List->return_playback_buffer_size,
List->playback_buffers);
fRecordStream.GetBuffers(List->flags, List->return_record_buffers,
List->return_record_channels, List->return_record_buffer_size,
List->record_buffers);
return B_OK;
}
status_t
Device::_MultiBufferExchange(multi_buffer_info* bufferInfo)
{
multi_buffer_info BufferInfo;
if (user_memcpy(&BufferInfo, bufferInfo, sizeof(multi_buffer_info)) != B_OK) {
return B_BAD_ADDRESS;
}
status_t status = B_NO_INIT;
if (!fRecordStream.IsActive()) {
status = fRecordStream.Start();
if (status != B_OK) {
ERROR("Error of starting record stream:%#010x\n", status);
return status;
}
}
if (!fPlaybackStream.IsActive()) {
status = fPlaybackStream.Start();
if (status != B_OK) {
ERROR("Error of starting playback stream:%#010x\n", status);
return status;
}
}
status = acquire_sem_etc(fBuffersReadySem, 1,
B_RELATIVE_TIMEOUT | B_CAN_INTERRUPT, 50000);
if (status == B_TIMED_OUT) {
ERROR("Timeout during buffers exchange.\n");
}
cpu_status cst = Lock();
fRecordStream.ExchangeBuffers(BufferInfo.recorded_real_time,
BufferInfo.recorded_frames_count, BufferInfo.record_buffer_cycle);
fPlaybackStream.ExchangeBuffers(BufferInfo.played_real_time,
BufferInfo.played_frames_count, BufferInfo.playback_buffer_cycle);
Unlock(cst);
if (user_memcpy(bufferInfo, &BufferInfo, sizeof(multi_buffer_info)) != B_OK) {
return B_BAD_ADDRESS;
}
return B_OK;
}
int32
Device::InterruptHandler(void *interruptParam)
{
Device *device = reinterpret_cast<Device*>(interruptParam);
if (device == 0) {
ERROR("Invalid parameter in the interrupt handler.\n");
return B_HANDLED_INTERRUPT;
}
bool wasHandled = false;
acquire_spinlock(&device->fHWSpinlock);
uint32 mask = device->ReadPCI32(RegMiscINT);
if (mask & 0x00000020) {
wasHandled = device->fRecordStream.InterruptHandler();
wasHandled = device->fPlaybackStream.InterruptHandler() || wasHandled;
}
release_spinlock(&device->fHWSpinlock);
return wasHandled ? B_INVOKE_SCHEDULER : B_UNHANDLED_INTERRUPT;
}
void
Device::SignalReadyBuffers()
{
release_sem_etc(fBuffersReadySem, 1, B_DO_NOT_RESCHEDULE);
}
status_t
Device::_ReserveDeviceOnBus(bool reserve)
{
status_t result = B_NO_INIT;
if (reserve) {
result = gPCI->reserve_device(fPCIInfo.bus, fPCIInfo.device,
fPCIInfo.function, DRIVER_NAME, this);
if (result != B_OK)
ERROR("Unable to reserve PCI device %d:%d:%d on bus:%#010x\n",
fPCIInfo.bus, fPCIInfo.device, fPCIInfo.function, result);
} else {
result = gPCI->unreserve_device(fPCIInfo.bus, fPCIInfo.device,
fPCIInfo.function, DRIVER_NAME, this);
}
return result;
}
uint8
Device::ReadPCI8(int offset)
{
return gPCI->read_io_8(fIOBase + offset);
}
uint16
Device::ReadPCI16(int offset)
{
return gPCI->read_io_16(fIOBase + offset);
}
uint32
Device::ReadPCI32(int offset)
{
return gPCI->read_io_32(fIOBase + offset);
}
void
Device::WritePCI8(int offset, uint8 value)
{
gPCI->write_io_8(fIOBase + offset, value);
}
void
Device::WritePCI16(int offset, uint16 value)
{
gPCI->write_io_16(fIOBase + offset, value);
}
void
Device::WritePCI32(int offset, uint32 value)
{
gPCI->write_io_32(fIOBase + offset, value);
}
cpu_status
Device::Lock()
{
cpu_status st = disable_interrupts();
acquire_spinlock(&fHWSpinlock);
return st;
}
void
Device::Unlock(cpu_status st)
{
release_spinlock(&fHWSpinlock);
restore_interrupts(st);
}
