mirror of
https://github.com/reactos/reactos.git
synced 2024-08-28 14:18:41 +00:00
491 lines
12 KiB
C
491 lines
12 KiB
C
/*
|
|
ReactOS
|
|
Sound Blaster driver
|
|
|
|
Programmers:
|
|
Andrew Greenwood
|
|
|
|
Notes:
|
|
Compatible with NT4
|
|
*/
|
|
|
|
#define NDEBUG
|
|
#include <sndblst.h>
|
|
|
|
|
|
/*
|
|
IRP DISPATCH ROUTINES
|
|
*/
|
|
|
|
NTSTATUS NTAPI
|
|
CreateSoundBlaster(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp)
|
|
{
|
|
PSOUND_BLASTER_PARAMETERS sb_device = DeviceObject->DeviceExtension;
|
|
|
|
DPRINT("CreateSoundBlaster() called - extension 0x%x\n", sb_device);
|
|
|
|
EnableSpeaker(sb_device);
|
|
/*SetOutputSampleRate(sb_device, 22*/
|
|
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Irp->IoStatus.Information = 0;
|
|
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS NTAPI
|
|
CloseSoundBlaster(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp)
|
|
{
|
|
//PSOUND_BLASTER_PARAMETERS sb_device = DeviceObject->DeviceExtension;
|
|
|
|
DPRINT("CloseSoundBlaster() called\n");
|
|
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Irp->IoStatus.Information = 0;
|
|
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS NTAPI
|
|
CleanupSoundBlaster(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp)
|
|
{
|
|
//PSOUND_BLASTER_PARAMETERS sb_device = DeviceObject->DeviceExtension;
|
|
|
|
DPRINT("CleanupSoundBlaster() called\n");
|
|
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Irp->IoStatus.Information = 0;
|
|
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS NTAPI
|
|
ControlSoundBlaster(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp)
|
|
{
|
|
PIO_STACK_LOCATION stack;
|
|
//PSOUND_BLASTER_PARAMETERS sb_device = DeviceObject->DeviceExtension;
|
|
|
|
DPRINT("ControlSoundBlaster() called\n");
|
|
|
|
stack = IoGetCurrentIrpStackLocation(Irp);
|
|
|
|
switch ( stack->Parameters.DeviceIoControl.IoControlCode)
|
|
{
|
|
/* TODO */
|
|
};
|
|
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Irp->IoStatus.Information = 0;
|
|
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS NTAPI
|
|
WriteSoundBlaster(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp)
|
|
{
|
|
//PSOUND_BLASTER_PARAMETERS sb_device = DeviceObject->DeviceExtension;
|
|
|
|
DPRINT("WriteSoundBlaster() called\n");
|
|
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Irp->IoStatus.Information = 0;
|
|
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
VOID NTAPI
|
|
UnloadSoundBlaster(
|
|
PDRIVER_OBJECT DriverObject)
|
|
{
|
|
DPRINT("Sound Blaster driver unload\n");
|
|
}
|
|
|
|
NTSTATUS NTAPI
|
|
OpenSubkey(
|
|
PUNICODE_STRING RegistryPath,
|
|
PWSTR Subkey,
|
|
ACCESS_MASK DesiredAccess,
|
|
OUT HANDLE* DevicesKeyHandle)
|
|
{
|
|
NTSTATUS status;
|
|
OBJECT_ATTRIBUTES attribs;
|
|
UNICODE_STRING subkey_name;
|
|
HANDLE key_handle;
|
|
|
|
/* TODO: Check for NULL ptr in DevicesKeyHandle */
|
|
|
|
InitializeObjectAttributes(&attribs,
|
|
RegistryPath,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
(PSECURITY_DESCRIPTOR) NULL);
|
|
|
|
status = ZwOpenKey(&key_handle, KEY_READ, &attribs);
|
|
|
|
if ( ! NT_SUCCESS(status) )
|
|
{
|
|
DPRINT("Couldn't open key %wZ\n", RegistryPath);
|
|
return status;
|
|
}
|
|
|
|
RtlInitUnicodeString(&subkey_name, Subkey);
|
|
|
|
InitializeObjectAttributes(&attribs,
|
|
&subkey_name,
|
|
OBJ_CASE_INSENSITIVE,
|
|
key_handle,
|
|
(PSECURITY_DESCRIPTOR) NULL);
|
|
|
|
status = ZwOpenKey(*DevicesKeyHandle, DesiredAccess, &attribs);
|
|
ZwClose(key_handle);
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
PWSTR NTAPI
|
|
AllocateRegistryPathInfo(
|
|
PUNICODE_STRING BasePath,
|
|
PUNICODE_STRING ParametersPath,
|
|
PKEY_BASIC_INFORMATION KeyInfo)
|
|
{
|
|
PWSTR name;
|
|
PWSTR pos;
|
|
|
|
DPRINT("Allocating memory for path info\n");
|
|
name = ExAllocatePool(PagedPool,
|
|
BasePath->Length + sizeof(WCHAR) +
|
|
ParametersPath->Length + sizeof(WCHAR) +
|
|
KeyInfo->NameLength + sizeof(UNICODE_NULL));
|
|
|
|
if ( ! name )
|
|
return NULL;
|
|
|
|
DPRINT("Copying info\n");
|
|
pos = name;
|
|
|
|
RtlCopyMemory((PVOID)Pos, (PVOID)BasePath->Buffer, BasePath->Length);
|
|
pos += BasePath->Length / sizeof(WCHAR);
|
|
pos[0] = '\\';
|
|
pos ++;
|
|
|
|
RtlCopyMemory((PVOID)Pos, (PVOID)ParametersPath->Buffer, ParametersPath->Length);
|
|
pos += ParametersPath->Length / sizeof(WCHAR);
|
|
pos[0] = '\\';
|
|
pos ++;
|
|
|
|
RtlCopyMemory((PVOID)Pos, (PVOID)ParametersPath->Buffer, ParametersPath->Length);
|
|
pos += KeyInfo->NameLength / sizeof(WCHAR);
|
|
pos[0] = UNICODE_NULL;
|
|
|
|
DPRINT("All OK\n");
|
|
return name;
|
|
}
|
|
|
|
#define FreeRegistryPathInfo(ptr) \
|
|
ExFreePool(ptr)
|
|
|
|
|
|
#define TAG_REG_INFO 'RegI'
|
|
#define TAG_REG_NAME 'RegN'
|
|
|
|
NTSTATUS NTAPI
|
|
EnumerateSubkey(
|
|
PUNICODE_STRING RegistryPath,
|
|
PWSTR Subkey,
|
|
PREGISTRY_CALLBACK_ROUTINE Callback,
|
|
PDRIVER_OBJECT DriverObject)
|
|
{
|
|
NTSTATUS status;
|
|
UNICODE_STRING subkey_name;
|
|
HANDLE devices_key_handle;
|
|
|
|
ULONG key_index = 0;
|
|
ULONG result_length;
|
|
|
|
status = OpenSubkey(RegistryPath, Subkey, KEY_ENUMERATE_SUB_KEYS, &devices_key_handle);
|
|
|
|
if ( ! NT_SUCCESS(status) )
|
|
return status;
|
|
|
|
while ( TRUE )
|
|
{
|
|
KEY_BASIC_INFORMATION test_info;
|
|
PKEY_BASIC_INFORMATION info;
|
|
ULONG size;
|
|
PWSTR name;
|
|
|
|
status = ZwEnumerateKey(devices_key_handle,
|
|
key_index,
|
|
KeyBasicInformation,
|
|
&test_info,
|
|
sizeof(test_info),
|
|
&result_length);
|
|
|
|
if ( status == STATUS_NO_MORE_ENTRIES )
|
|
break;
|
|
|
|
size = result_length + FIELD_OFFSET(KEY_BASIC_INFORMATION, Name[0]);
|
|
|
|
info = (PKEY_BASIC_INFORMATION) ExAllocatePoolWithTag(PagedPool, size, TAG_REG_INFO);
|
|
|
|
if ( ! info )
|
|
{
|
|
DPRINT("Out of memory\n");
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
break;
|
|
}
|
|
|
|
status = ZwEnumerateKey(devices_key_handle,
|
|
key_index,
|
|
KeyBasicInformation,
|
|
info,
|
|
size,
|
|
&result_length);
|
|
|
|
if ( ! NT_SUCCESS(status) )
|
|
{
|
|
DPRINT("Unable to enumerate keys\n");
|
|
ExFreePoolWithTag(info, TAG_REG_INFO);
|
|
status = STATUS_INTERNAL_ERROR;
|
|
break;
|
|
}
|
|
|
|
/* Is this ok? */
|
|
RtlInitUnicodeString(&subkey_name, Subkey);
|
|
|
|
name = AllocateRegistryPathInfo(RegistryPath, &subkey_name, info);
|
|
|
|
if ( ! name )
|
|
{
|
|
DPRINT("Out of memory\n");
|
|
ExFreePoolWithTag(info, TAG_REG_INFO);
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
break;
|
|
}
|
|
|
|
ExFreePoolWithTag(info, TAG_REG_INFO);
|
|
|
|
/* Call the callback */
|
|
status = Callback(DriverObject, name);
|
|
|
|
FreeRegistryPathInfo(name);
|
|
|
|
if ( ! NT_SUCCESS(status) )
|
|
{
|
|
DPRINT("Callback FAILED\n");
|
|
break;
|
|
}
|
|
|
|
key_index ++;
|
|
}
|
|
|
|
ZwClose(devices_key_handle);
|
|
|
|
DPRINT("Found %d subkey entries\n", key_index);
|
|
|
|
if ( ( key_index == 0 ) && ( status == STATUS_NO_MORE_ENTRIES ) )
|
|
return STATUS_DEVICE_CONFIGURATION_ERROR;
|
|
|
|
if ( status == STATUS_NO_MORE_ENTRIES )
|
|
status = STATUS_SUCCESS;
|
|
|
|
return status;
|
|
}
|
|
|
|
#define EnumerateDeviceKeys(path, callback, driver_obj) \
|
|
EnumerateSubkey(path, L"Devices", callback, driver_obj)
|
|
|
|
|
|
NTSTATUS
|
|
CreateDeviceName(
|
|
PCWSTR PrePrefix,
|
|
PCWSTR Prefix,
|
|
UCHAR Index,
|
|
PUNICODE_STRING DeviceName)
|
|
{
|
|
UNICODE_STRING number;
|
|
WCHAR number_buffer[5];
|
|
UNICODE_STRING unicode_pre_prefix;
|
|
UNICODE_STRING unicode_prefix;
|
|
ULONG size;
|
|
|
|
RtlInitUnicodeString(&unicode_pre_prefix, PrePrefix);
|
|
RtlInitUnicodeString(&unicode_prefix, Prefix);
|
|
|
|
size = unicode_pre_prefix.Length +
|
|
unicode_prefix.Length +
|
|
sizeof(number_buffer) +
|
|
sizeof(UNICODE_NULL);
|
|
|
|
DeviceName->Buffer = ExAllocatePool(PagedPool, size);
|
|
DeviceName->MaximumLength = (USHORT) size;
|
|
|
|
if ( ! DeviceName->Buffer )
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
RtlCopyUnicodeString(DeviceName, &unicode_pre_prefix);
|
|
RtlAppendUnicodeStringToString(DeviceName, &unicode_prefix);
|
|
|
|
if ( Index != 255 )
|
|
{
|
|
number.Buffer = number_buffer;
|
|
number.MaximumLength = sizeof(number_buffer);
|
|
|
|
RtlIntegerToUnicodeString((ULONG) Index, 10, &number);
|
|
RtlAppendUnicodeStringToString(DeviceName, &number);
|
|
}
|
|
|
|
DeviceName->Buffer[DeviceName->Length / sizeof(UNICODE_NULL)] = UNICODE_NULL;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS NTAPI
|
|
InitializeSoundBlaster(
|
|
PDRIVER_OBJECT DriverObject,
|
|
PWSTR RegistryPath)
|
|
{
|
|
NTSTATUS status;
|
|
PDEVICE_OBJECT device_object;
|
|
PSOUND_BLASTER_PARAMETERS parameters = NULL;
|
|
UNICODE_STRING device_name;
|
|
UNICODE_STRING dos_device_name;
|
|
|
|
UCHAR device_index = 0;
|
|
|
|
DPRINT("Initializing a Sound Blaster device\n");
|
|
|
|
/* Change these later */
|
|
status = CreateDeviceName(L"",
|
|
L"\\Device\\WaveOut",
|
|
device_index,
|
|
&device_name);
|
|
|
|
if ( ! NT_SUCCESS(status) )
|
|
return status;
|
|
|
|
status = CreateDeviceName(L"\\DosDevices\\",
|
|
L"\\Device\\WaveOut" + wcslen(L"\\Device\\"),
|
|
device_index,
|
|
&dos_device_name);
|
|
|
|
if ( ! NT_SUCCESS(status) )
|
|
{
|
|
/* TODO */
|
|
return status;
|
|
}
|
|
|
|
DPRINT("Device: %wZ\n", &device_name);
|
|
DPRINT("Symlink: %wZ\n", &dos_device_name);
|
|
|
|
/*
|
|
Create the device and DOS symlink
|
|
*/
|
|
|
|
status = IoCreateDevice(DriverObject,
|
|
sizeof(SOUND_BLASTER_PARAMETERS),
|
|
&device_name,
|
|
FILE_DEVICE_SOUND,
|
|
0,
|
|
FALSE,
|
|
&device_object);
|
|
|
|
if ( ! NT_SUCCESS(status) )
|
|
return status;
|
|
|
|
DPRINT("Created a device extension at 0x%x\n", device_object->DeviceExtension);
|
|
parameters = device_object->DeviceExtension;
|
|
|
|
status = IoCreateSymbolicLink(&dos_device_name, &device_name);
|
|
|
|
ExFreePool(dos_device_name.Buffer);
|
|
ExFreePool(device_name.Buffer);
|
|
|
|
if ( ! NT_SUCCESS(status) )
|
|
{
|
|
IoDeleteDevice(device_object);
|
|
device_object = NULL;
|
|
return status;
|
|
}
|
|
|
|
/* IoRegisterShutdownNotification( */
|
|
|
|
/*
|
|
Settings
|
|
*/
|
|
|
|
device_object->AlignmentRequirement = FILE_BYTE_ALIGNMENT;
|
|
|
|
parameters->driver = DriverObject;
|
|
parameters->registry_path = RegistryPath;
|
|
parameters->port = DEFAULT_PORT;
|
|
parameters->irq = DEFAULT_IRQ;
|
|
parameters->dma = DEFAULT_DMA;
|
|
parameters->buffer_size = DEFAULT_BUFFER_SIZE;
|
|
|
|
/* TODO: Load the settings from the registry */
|
|
|
|
DPRINT("Port %x IRQ %d DMA %d\n", parameters->port, parameters->irq, parameters->dma);
|
|
|
|
DPRINT("Resetting the sound card\n");
|
|
|
|
if ( ! ResetSoundBlaster(parameters) )
|
|
{
|
|
/* TODO */
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
/*
|
|
DPRINT("What kind of SB card is this?\n");
|
|
GetSoundBlasterModel(parameters);
|
|
*/
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
NTSTATUS NTAPI
|
|
DriverEntry(
|
|
PDRIVER_OBJECT DriverObject,
|
|
PUNICODE_STRING RegistryPath)
|
|
{
|
|
NTSTATUS status;
|
|
|
|
DPRINT("Sound Blaster driver 0.1 by Silver Blade\n");
|
|
|
|
DriverObject->Flags = 0;
|
|
DriverObject->MajorFunction[IRP_MJ_CREATE] = CreateSoundBlaster;
|
|
DriverObject->MajorFunction[IRP_MJ_CLOSE] = CloseSoundBlaster;
|
|
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = CleanupSoundBlaster;
|
|
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ControlSoundBlaster;
|
|
DriverObject->MajorFunction[IRP_MJ_WRITE] = WriteSoundBlaster;
|
|
DriverObject->DriverUnload = UnloadSoundBlaster;
|
|
|
|
DPRINT("Beginning device key enumeration\n");
|
|
|
|
status = EnumerateDeviceKeys(RegistryPath, *InitializeSoundBlaster, DriverObject);
|
|
|
|
return status;
|
|
}
|