sndblst.c

Go to the documentation of this file.

/*
 *
 * COPYRIGHT:           See COPYING in the top level directory
 * PROJECT:             ReactOS Sound System
 * FILE:                drivers/multimedia/audio/sndblst/sndblst.c
 * PURPOSE:             Sound Blaster / Pro / 16 driver
 * PROGRAMMER:          Andrew Greenwood (silverblade@reactos.org)
 *
 * UPDATE HISTORY:      Feb 25, 2009: New rewrite started
 *
 */

/* DEFINES AND INCLUDES ******************************************************/

#include <ntddk.h>
#include <windef.h>
#include <mmsystem.h>
#include <debug.h>

#define CompleteIrpAndReturn(irp, status) \
    irp->IoStatus.Status = status; \
    irp->IoStatus.Information = 0; \
    IoCompleteRequest(Irp, IO_NO_INCREMENT); \
    return status;


/* FORWARD DECLARATIONS *****************************************************/

static VOID NTAPI
UnloadSoundBlaster(PDRIVER_OBJECT DriverObject);


/* DEVICE "DISCOVERY" *******************************************************/
/* Nb: These need to go in the helper lib */

typedef NTSTATUS (*SOUNDDEVICEENUMERATIONCALLBACK)(
    IN  PUNICODE_STRING DeviceRegistryPath);

NTSTATUS
EnumerateSoundDevices(
    IN  PUNICODE_STRING RegistryPath,
    IN  PWSTR RegistrySubKey,
    IN  SOUNDDEVICEENUMERATIONCALLBACK Callback)
{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES RegAttributes;
    HKEY MainKeyHandle, ChildKeyHandle;
    UNICODE_STRING UnicodeSubkeyName, DeviceKeyName;
    KEY_BASIC_INFORMATION KeyInfo, *FinalKeyInfo;
    ULONG i = 0, NeededDataLength = 0, FinalDataLength = 0, NameLength = 0;

    /* Turn the subkey name into a Unicode string */
    RtlInitUnicodeString(&UnicodeSubkeyName, RegistrySubKey);

    /* Open the registry key for the service */
    InitializeObjectAttributes(&RegAttributes,
                               RegistryPath,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               (PSECURITY_DESCRIPTOR) NULL);

    Status = ZwOpenKey(&MainKeyHandle, KEY_READ, &RegAttributes);

    if ( ! NT_SUCCESS(Status) )
    {
        DPRINT("Failed to open registry key\n");
        return Status;
    }

    /* Open the subkey usually named "Parameters" */
    InitializeObjectAttributes(&RegAttributes,
                               &UnicodeSubkeyName,
                               OBJ_CASE_INSENSITIVE,
                               MainKeyHandle,
                               (PSECURITY_DESCRIPTOR) NULL);

    Status = ZwOpenKey(&ChildKeyHandle, KEY_ENUMERATE_SUB_KEYS, &RegAttributes);

    /* We're done with the main key now */
    ZwClose(MainKeyHandle);

    if ( ! NT_SUCCESS(Status) )
    {
        DPRINT("Failed to open registry subkeys for enumeration\n");
        return Status;
    }

    /* Enumerate through the device keys */
    while ( ( Status = ZwEnumerateKey(ChildKeyHandle,
                                      i,
                                      KeyBasicInformation,
                                      &KeyInfo,
                                      sizeof(KEY_BASIC_INFORMATION),
                                      &NeededDataLength) ) != STATUS_NO_MORE_ENTRIES )
    {
        PWSTR EnumeratedKeyName, StartOfEnumeratedKeyName;

        DPRINT("Found subkey %d\n", i);

        FinalDataLength = NeededDataLength + FIELD_OFFSET(KEY_BASIC_INFORMATION, Name[0]);
        DPRINT("Allocating %d bytes\n", FinalDataLength);

        FinalKeyInfo = (PKEY_BASIC_INFORMATION) ExAllocatePool(PagedPool, FinalDataLength);

        if ( ! FinalKeyInfo )
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }

        /* This time we get the real info */
        Status = ZwEnumerateKey(ChildKeyHandle,
                                i,
                                KeyBasicInformation,
                                FinalKeyInfo,
                                FinalDataLength,
                                &NeededDataLength);

        if ( ! NT_SUCCESS(Status) )
        {
            DPRINT("FAILED to enumerate key!\n");
        }
        else
        {
            NameLength = RegistryPath->Length + sizeof(WCHAR) +
                         UnicodeSubkeyName.Length + sizeof(WCHAR) +
                         FinalKeyInfo->NameLength + sizeof(UNICODE_NULL);

            DPRINT("Allocating memory for name (%d bytes)\n", NameLength);

            EnumeratedKeyName = (PWSTR) ExAllocatePool(PagedPool, NameLength);

            if ( ! EnumeratedKeyName )
            {
                ExFreePool((PVOID)FinalKeyInfo);
                Status = STATUS_INSUFFICIENT_RESOURCES;
                break;
            }

            StartOfEnumeratedKeyName = EnumeratedKeyName;

            /* Start building the registry path using the service key */
            RtlCopyMemory(EnumeratedKeyName,
                          RegistryPath->Buffer,
                          RegistryPath->Length);

            EnumeratedKeyName += RegistryPath->Length / sizeof(WCHAR);
            EnumeratedKeyName[0] = '\\';
            ++ EnumeratedKeyName;

            /* Append the parameters subkey */
            RtlCopyMemory(EnumeratedKeyName,
                          RegistrySubKey,
                          UnicodeSubkeyName.Length);

            EnumeratedKeyName += UnicodeSubkeyName.Length / sizeof(WCHAR);
            EnumeratedKeyName[0] = '\\';
            ++ EnumeratedKeyName;

            /* And finally append the enumerated key name */
            RtlCopyMemory(EnumeratedKeyName,
                          FinalKeyInfo->Name,
                          FinalKeyInfo->NameLength);

            EnumeratedKeyName += FinalKeyInfo->NameLength / sizeof(WCHAR);
            EnumeratedKeyName[0] = UNICODE_NULL;

            /* Reset pointer */
            EnumeratedKeyName = StartOfEnumeratedKeyName;

            /* Convert into a Unicode string for the callback */
            RtlInitUnicodeString(&DeviceKeyName, EnumeratedKeyName);

            Callback(&DeviceKeyName);

            /* No longer need the key name */
            ExFreePool((PVOID)EnumeratedKeyName);
            EnumeratedKeyName = NULL;
        }

        /* No longer need the key info */
        ExFreePool((PVOID)FinalKeyInfo);
        FinalKeyInfo = NULL;

        ++ i;
    }

    /* We're done with enumeration so close this */
    ZwClose(ChildKeyHandle);

    /* This isn't an error */
    if ( Status == STATUS_NO_MORE_ENTRIES )
    {
        Status = STATUS_SUCCESS;
    }

    /* No devices configured? */
    if ( i == 0 && Status == STATUS_NO_MORE_ENTRIES )
    {
        Status = STATUS_DEVICE_CONFIGURATION_ERROR;
    }

    return Status;
}

NTSTATUS
PublishWaveOutDevice(
    IN  DWORD HardwareDeviceIndex,
    IN  PWSTR BaseDeviceName,
    IN  DWORD DeviceIndex,
    IN  LPWAVEOUTCAPS Capabilities)
{
    return STATUS_SUCCESS;
}


typedef struct _SOUND_BLASTER_DEVICE
{
    DWORD   BasePort;
    DWORD   MidiUartBasePort;

    DWORD   Irq;

    DWORD   DmaChannel_8;
    DWORD   DmaChannel_16;

    DWORD   DspVersion;

    DWORD   ActualDmaBufferSize;
    DWORD   DmaBufferSize;
} SOUND_BLASTER_DEVICE;


NTSTATUS
AllocateSoundBlasterStructure(OUT SOUND_BLASTER_DEVICE* SoundBlasterDevice)
{
    return STATUS_NOT_IMPLEMENTED;
}

/* callback */
/*
    Configuration options within the registry:
    REG_DWORD   Actual Dma Buffer Size      0x00004000
    REG_DWORD   Configuration Error         0xffffffff
    REG_DWORD   Dma Buffer Size             0x00004000
    REG_DWORD   DmaChannel                  0x00000001
    REG_DWORD   DmaChannel16                0x00000005
    REG_DWORD   DSP Version                 0x00000405
    REG_DWORD   Interrupt                   0x00000005
    REG_DWORD   Load Type                   0x00000000
    REG_BINARY  Mixer Settings              ??
    REG_DWORD   MPU401 Port                 0xffffffff
    REG_DWORD   Port                        0x00000220
*/

NTSTATUS
ConfigureSoundBlasterDevice(IN PUNICODE_STRING DeviceRegistryPath)
{
    OBJECT_ATTRIBUTES RegAttributes;
    NTSTATUS Status = STATUS_SUCCESS;
    HKEY ConfigKeyHandle;

    DPRINT("Configuring Sound Blaster (config at %S)\n", DeviceRegistryPath->Buffer);

    if ( ! DeviceRegistryPath )
    {
        return STATUS_INVALID_PARAMETER;
    }

    /* Open the registry key */
    InitializeObjectAttributes(&RegAttributes,
                               DeviceRegistryPath,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               (PSECURITY_DESCRIPTOR) NULL);

    Status = ZwOpenKey(&ConfigKeyHandle, KEY_READ, &RegAttributes);

    if ( ! NT_SUCCESS(Status) )
    {
        DPRINT("Failed to open config registry key\n");
        return Status;
    }

    /* Read configuration */
    DPRINT("Reading configuration\n");

    //Status = ZwQueryValueKey(ConfigKeyHandle,

    return Status;
}


/* IRP DISPATCHERS **********************************************************/

static NTSTATUS NTAPI
CreateSoundBlaster(
    IN  PDEVICE_OBJECT DeviceObject,
    IN  PIRP Irp)
{
    DPRINT("Sound Blaster driver received IRP_MJ_CREATE\n");

    CompleteIrpAndReturn(Irp, STATUS_SUCCESS);
}

static NTSTATUS NTAPI
CloseSoundBlaster(
    IN  PDEVICE_OBJECT DeviceObject,
    IN  PIRP Irp)
{
    DPRINT("Sound Blaster driver received IRP_MJ_CLOSE\n");

    CompleteIrpAndReturn(Irp, STATUS_SUCCESS);
}

static NTSTATUS NTAPI
CleanupSoundBlaster(
    IN  PDEVICE_OBJECT DeviceObject,
    IN  PIRP Irp)
{
    DPRINT("Sound Blaster driver received IRP_MJ_CLEANUP\n");

    CompleteIrpAndReturn(Irp, STATUS_SUCCESS);
}

static NTSTATUS NTAPI
ControlSoundBlaster(
    IN  PDEVICE_OBJECT DeviceObject,
    IN  PIRP Irp)
{
    DPRINT("Sound Blaster driver received IRP_MJ_CONTROL\n");

    CompleteIrpAndReturn(Irp, STATUS_SUCCESS);
}

static NTSTATUS NTAPI
WriteToSoundBlaster(
    IN  PDEVICE_OBJECT DeviceObject,
    IN  PIRP Irp)
{
    DPRINT("Sound Blaster driver received IRP_MJ_WRITE\n");

    CompleteIrpAndReturn(Irp, STATUS_SUCCESS);
}


/* DRIVER ENTRYPOINT ********************************************************/

NTSTATUS NTAPI
DriverEntry(
    IN  PDRIVER_OBJECT DriverObject,
    IN  PUNICODE_STRING RegistryPath)
{
    NTSTATUS Status = STATUS_SUCCESS;

    DPRINT("Sound Blaster driver by silverblade\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] = WriteToSoundBlaster;
    DriverObject->DriverUnload = UnloadSoundBlaster;

    EnumerateSoundDevices(RegistryPath, L"Parameters", ConfigureSoundBlasterDevice);

    return Status;
}

static VOID NTAPI
UnloadSoundBlaster(IN PDRIVER_OBJECT DriverObject)
{
    DPRINT("Sound Blaster driver is being unloaded\n");
}