drivers/multimedia/audio/sb16_nt4.old/main.c

   1 /*
   2     ReactOS
   3     Sound Blaster driver
   4
   5     Programmers:
   6         Andrew Greenwood
   7
   8     Notes:
   9         Compatible with NT4
  10 */
  11
  12 #define NDEBUG
  13 #include <sndblst.h>
  14
  15
  16 /*
  17     IRP DISPATCH ROUTINES
  18 */
  19
  20 NTSTATUS NTAPI
  21 CreateSoundBlaster(
  22     PDEVICE_OBJECT DeviceObject,
  23     PIRP Irp)
  24 {
  25     PSOUND_BLASTER_PARAMETERS sb_device = DeviceObject->DeviceExtension;
  26
  27     DPRINT("CreateSoundBlaster() called - extension 0x%x\n", sb_device);
  28
  29     EnableSpeaker(sb_device);
  30     /*SetOutputSampleRate(sb_device, 22*/
  31
  32     Irp->IoStatus.Status = STATUS_SUCCESS;
  33     Irp->IoStatus.Information = 0;
  34
  35     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  36
  37     return STATUS_SUCCESS;
  38 }
  39
  40 NTSTATUS NTAPI
  41 CloseSoundBlaster(
  42     PDEVICE_OBJECT DeviceObject,
  43     PIRP Irp)
  44 {
  45     //PSOUND_BLASTER_PARAMETERS sb_device = DeviceObject->DeviceExtension;
  46
  47     DPRINT("CloseSoundBlaster() called\n");
  48
  49     Irp->IoStatus.Status = STATUS_SUCCESS;
  50     Irp->IoStatus.Information = 0;
  51
  52     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  53
  54     return STATUS_SUCCESS;
  55 }
  56
  57 NTSTATUS NTAPI
  58 CleanupSoundBlaster(
  59     PDEVICE_OBJECT DeviceObject,
  60     PIRP Irp)
  61 {
  62     //PSOUND_BLASTER_PARAMETERS sb_device = DeviceObject->DeviceExtension;
  63
  64     DPRINT("CleanupSoundBlaster() called\n");
  65
  66     Irp->IoStatus.Status = STATUS_SUCCESS;
  67     Irp->IoStatus.Information = 0;
  68
  69     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  70
  71     return STATUS_SUCCESS;
  72 }
  73
  74 NTSTATUS NTAPI
  75 ControlSoundBlaster(
  76     PDEVICE_OBJECT DeviceObject,
  77     PIRP Irp)
  78 {
  79     PIO_STACK_LOCATION stack;
  80     //PSOUND_BLASTER_PARAMETERS sb_device = DeviceObject->DeviceExtension;
  81
  82     DPRINT("ControlSoundBlaster() called\n");
  83
  84     stack = IoGetCurrentIrpStackLocation(Irp);
  85
  86     switch ( stack->Parameters.DeviceIoControl.IoControlCode)
  87     {
  88         /* TODO */
  89     };
  90
  91     Irp->IoStatus.Status = STATUS_SUCCESS;
  92     Irp->IoStatus.Information = 0;
  93
  94     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  95
  96     return STATUS_SUCCESS;
  97 }
  98
  99 NTSTATUS NTAPI
 100 WriteSoundBlaster(
 101     PDEVICE_OBJECT DeviceObject,
 102     PIRP Irp)
 103 {
 104     //PSOUND_BLASTER_PARAMETERS sb_device = DeviceObject->DeviceExtension;
 105
 106     DPRINT("WriteSoundBlaster() called\n");
 107
 108     Irp->IoStatus.Status = STATUS_SUCCESS;
 109     Irp->IoStatus.Information = 0;
 110
 111     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 112
 113     return STATUS_SUCCESS;
 114 }
 115
 116 VOID NTAPI
 117 UnloadSoundBlaster(
 118     PDRIVER_OBJECT DriverObject)
 119 {
 120     DPRINT("Sound Blaster driver unload\n");
 121 }
 122
 123 NTSTATUS NTAPI
 124 OpenSubkey(
 125     PUNICODE_STRING RegistryPath,
 126     PWSTR Subkey,
 127     ACCESS_MASK DesiredAccess,
 128     OUT HANDLE* DevicesKeyHandle)
 129 {
 130     NTSTATUS status;
 131     OBJECT_ATTRIBUTES attribs;
 132     UNICODE_STRING subkey_name;
 133     HANDLE key_handle;
 134
 135     /* TODO: Check for NULL ptr in DevicesKeyHandle */
 136
 137     InitializeObjectAttributes(&attribs,
 138                                RegistryPath,
 139                                OBJ_CASE_INSENSITIVE,
 140                                NULL,
 141                                (PSECURITY_DESCRIPTOR) NULL);
 142
 143     status = ZwOpenKey(&key_handle, KEY_READ, &attribs);
 144
 145     if ( ! NT_SUCCESS(status) )
 146     {
 147         DPRINT("Couldn't open subkey %wZ\n", Subkey);
 148         return status;
 149     }
 150
 151     RtlInitUnicodeString(&subkey_name, Subkey);
 152
 153     InitializeObjectAttributes(&attribs,
 154                                &subkey_name,
 155                                OBJ_CASE_INSENSITIVE,
 156                                key_handle,
 157                                (PSECURITY_DESCRIPTOR) NULL);
 158
 159     status = ZwOpenKey(*DevicesKeyHandle, DesiredAccess, &attribs);
 160     ZwClose(key_handle);
 161
 162     return status;
 163 }
 164
 165
 166 PWSTR NTAPI
 167 AllocateRegistryPathInfo(
 168     PUNICODE_STRING BasePath,
 169     PUNICODE_STRING ParametersPath,
 170     PKEY_BASIC_INFORMATION KeyInfo)
 171 {
 172     PWSTR name;
 173     PWSTR pos;
 174
 175     DPRINT("Allocating memory for path info\n");
 176     name = ExAllocatePool(PagedPool,
 177                           BasePath->Length + sizeof(WCHAR) +
 178                           ParametersPath->Length + sizeof(WCHAR) +
 179                           KeyInfo->NameLength + sizeof(UNICODE_NULL));
 180
 181     if ( ! name )
 182         return NULL;
 183
 184     DPRINT("Copying info\n");
 185     pos = name;
 186
 187     RtlCopyMemory((PVOID)Pos, (PVOID)BasePath->Buffer, BasePath->Length);
 188     pos += BasePath->Length / sizeof(WCHAR);
 189     pos[0] = '\\';
 190     pos ++;
 191
 192     RtlCopyMemory((PVOID)Pos, (PVOID)ParametersPath->Buffer, ParametersPath->Length);
 193     pos += ParametersPath->Length / sizeof(WCHAR);
 194     pos[0] = '\\';
 195     pos ++;
 196
 197     RtlCopyMemory((PVOID)Pos, (PVOID)ParametersPath->Buffer, ParametersPath->Length);
 198     pos += KeyInfo->NameLength / sizeof(WCHAR);
 199     pos[0] = UNICODE_NULL;
 200
 201     DPRINT("All OK\n");
 202     return name;
 203 }
 204
 205 #define FreeRegistryPathInfo(ptr) \
 206     ExFreePool(ptr)
 207
 208
 209 #define TAG_REG_INFO 'RegI'
 210 #define TAG_REG_NAME 'RegN'
 211
 212 NTSTATUS NTAPI
 213 EnumerateSubkey(
 214     PUNICODE_STRING RegistryPath,
 215     PWSTR Subkey,
 216     PREGISTRY_CALLBACK_ROUTINE Callback,
 217     PDRIVER_OBJECT DriverObject)
 218 {
 219     NTSTATUS status;
 220     UNICODE_STRING subkey_name;
 221     HANDLE devices_key_handle;
 222
 223     ULONG key_index = 0;
 224     ULONG result_length;
 225
 226     status = OpenSubkey(RegistryPath, Subkey, KEY_ENUMERATE_SUB_KEYS, &devices_key_handle);
 227
 228     if ( ! NT_SUCCESS(status) )
 229         return status;
 230
 231     while ( TRUE )
 232     {
 233         KEY_BASIC_INFORMATION test_info;
 234         PKEY_BASIC_INFORMATION info;
 235         ULONG size;
 236         PWSTR name;
 237
 238         status = ZwEnumerateKey(devices_key_handle,
 239                                 key_index,
 240                                 KeyBasicInformation,
 241                                 &test_info,
 242                                 sizeof(test_info),
 243                                 &result_length);
 244
 245         if ( status == STATUS_NO_MORE_ENTRIES )
 246             break;
 247
 248         size = result_length + FIELD_OFFSET(KEY_BASIC_INFORMATION, Name[0]);
 249
 250         info = (PKEY_BASIC_INFORMATION) ExAllocatePoolWithTag(PagedPool, size, TAG_REG_INFO);
 251
 252         if ( ! info )
 253         {
 254             DPRINT("Out of memory\n");
 255             status = STATUS_INSUFFICIENT_RESOURCES;
 256             break;
 257         }
 258
 259         status = ZwEnumerateKey(devices_key_handle,
 260                                 key_index,
 261                                 KeyBasicInformation,
 262                                 info,
 263                                 size,
 264                                 &result_length);
 265
 266         if ( ! NT_SUCCESS(status) )
 267         {
 268             DPRINT("Unable to enumerate keys\n");
 269             ExFreePoolWithTag(info, TAG_REG_INFO);
 270             status = STATUS_INTERNAL_ERROR;
 271             break;
 272         }
 273
 274         /* Is this ok? */
 275         RtlInitUnicodeString(&subkey_name, Subkey);
 276
 277         name = AllocateRegistryPathInfo(RegistryPath, &subkey_name, info);
 278
 279         if ( ! name )
 280         {
 281             DPRINT("Out of memory\n");
 282             ExFreePoolWithTag(info, TAG_REG_INFO);
 283             status = STATUS_INSUFFICIENT_RESOURCES;
 284             break;
 285         }
 286
 287         ExFreePoolWithTag(info, TAG_REG_INFO);
 288
 289         /* Call the callback */
 290         status = Callback(DriverObject, name);
 291
 292         FreeRegistryPathInfo(name);
 293
 294         if ( ! NT_SUCCESS(status) )
 295         {
 296             DPRINT("Callback FAILED\n");
 297             break;
 298         }
 299
 300         key_index ++;
 301     }
 302
 303     ZwClose(devices_key_handle);
 304
 305     DPRINT("Found %d subkey entries\n", key_index);
 306
 307     if ( ( key_index == 0 ) && ( status == STATUS_NO_MORE_ENTRIES ) )
 308         return STATUS_DEVICE_CONFIGURATION_ERROR;
 309
 310     if ( status == STATUS_NO_MORE_ENTRIES )
 311         status = STATUS_SUCCESS;
 312
 313     return status;
 314 }
 315
 316 #define EnumerateDeviceKeys(path, callback, driver_obj) \
 317     EnumerateSubkey(path, L"Devices", callback, driver_obj)
 318
 319
 320 NTSTATUS
 321 CreateDeviceName(
 322     PCWSTR PrePrefix,
 323     PCWSTR Prefix,
 324     UCHAR Index,
 325     PUNICODE_STRING DeviceName)
 326 {
 327     UNICODE_STRING number;
 328     WCHAR number_buffer[5];
 329     UNICODE_STRING unicode_pre_prefix;
 330     UNICODE_STRING unicode_prefix;
 331     ULONG size;
 332
 333     RtlInitUnicodeString(&unicode_pre_prefix, PrePrefix);
 334     RtlInitUnicodeString(&unicode_prefix, Prefix);
 335
 336     size = unicode_pre_prefix.Length +
 337            unicode_prefix.Length +
 338            sizeof(number_buffer) +
 339            sizeof(UNICODE_NULL);
 340
 341     DeviceName->Buffer = ExAllocatePool(PagedPool, size);
 342     DeviceName->MaximumLength = (USHORT) size;
 343
 344     if ( ! DeviceName->Buffer )
 345         return STATUS_INSUFFICIENT_RESOURCES;
 346
 347     RtlCopyUnicodeString(DeviceName, &unicode_pre_prefix);
 348     RtlAppendUnicodeStringToString(DeviceName, &unicode_prefix);
 349
 350     if ( Index != 255 )
 351     {
 352         number.Buffer = number_buffer;
 353         number.MaximumLength = sizeof(number_buffer);
 354
 355         RtlIntegerToUnicodeString((ULONG) Index, 10, &number);
 356         RtlAppendUnicodeStringToString(DeviceName, &number);
 357     }
 358
 359     DeviceName->Buffer[DeviceName->Length / sizeof(UNICODE_NULL)] = UNICODE_NULL;
 360
 361     return STATUS_SUCCESS;
 362 }
 363
 364 NTSTATUS NTAPI
 365 InitializeSoundBlaster(
 366     PDRIVER_OBJECT DriverObject,
 367     PWSTR RegistryPath)
 368 {
 369     NTSTATUS status;
 370     PDEVICE_OBJECT device_object;
 371     PSOUND_BLASTER_PARAMETERS parameters = NULL;
 372     UNICODE_STRING device_name;
 373     UNICODE_STRING dos_device_name;
 374
 375     UCHAR device_index = 0;
 376
 377     DPRINT("Initializing a Sound Blaster device\n");
 378
 379     /* Change these later */
 380     status = CreateDeviceName(L"",
 381                               L"\\Device\\WaveOut",
 382                               device_index,
 383                               &device_name);
 384
 385     if ( ! NT_SUCCESS(status) )
 386         return status;
 387
 388     status = CreateDeviceName(L"\\DosDevices\\",
 389                               L"\\Device\\WaveOut" + wcslen(L"\\Device\\"),
 390                               device_index,
 391                               &dos_device_name);
 392
 393     if ( ! NT_SUCCESS(status) )
 394     {
 395         /* TODO */
 396         return status;
 397     }
 398
 399     DPRINT("Device: %wZ\n", device_name);
 400     DPRINT("Symlink: %wZ\n", dos_device_name);
 401
 402     /*
 403         Create the device and DOS symlink
 404     */
 405
 406     status = IoCreateDevice(DriverObject,
 407                             sizeof(SOUND_BLASTER_PARAMETERS),
 408                             &device_name,
 409                             FILE_DEVICE_SOUND,
 410                             0,
 411                             FALSE,
 412                             &device_object);
 413
 414     if ( ! NT_SUCCESS(status) )
 415         return status;
 416
 417     DPRINT("Created a device extension at 0x%x\n", device_object->DeviceExtension);
 418     parameters = device_object->DeviceExtension;
 419
 420     status = IoCreateSymbolicLink(&dos_device_name, &device_name);
 421
 422     ExFreePool(dos_device_name.Buffer);
 423     ExFreePool(device_name.Buffer);
 424
 425     if ( ! NT_SUCCESS(status) )
 426     {
 427         IoDeleteDevice(device_object);
 428         device_object = NULL;
 429         return status;
 430     }
 431
 432     /* IoRegisterShutdownNotification( */
 433
 434     /*
 435         Settings
 436     */
 437
 438     device_object->AlignmentRequirement = FILE_BYTE_ALIGNMENT;
 439
 440     parameters->driver = DriverObject;
 441     parameters->registry_path = RegistryPath;
 442     parameters->port = DEFAULT_PORT;
 443     parameters->irq = DEFAULT_IRQ;
 444     parameters->dma = DEFAULT_DMA;
 445     parameters->buffer_size = DEFAULT_BUFFER_SIZE;
 446
 447     /* TODO: Load the settings from the registry */
 448
 449     DPRINT("Port %x IRQ %d DMA %d\n", parameters->port, parameters->irq, parameters->dma);
 450
 451     DPRINT("Resetting the sound card\n");
 452
 453     if ( ! ResetSoundBlaster(parameters) )
 454     {
 455         /* TODO */
 456         return STATUS_UNSUCCESSFUL;
 457     }
 458
 459     /*
 460     DPRINT("What kind of SB card is this?\n");
 461     GetSoundBlasterModel(parameters);
 462     */
 463
 464     return STATUS_SUCCESS;
 465 }
 466
 467
 468 NTSTATUS NTAPI
 469 DriverEntry(
 470     PDRIVER_OBJECT DriverObject,
 471     PUNICODE_STRING RegistryPath)
 472 {
 473     NTSTATUS status;
 474
 475     DPRINT("Sound Blaster driver 0.1 by Silver Blade\n");
 476
 477     DriverObject->Flags = 0;
 478     DriverObject->MajorFunction[IRP_MJ_CREATE] = CreateSoundBlaster;
 479     DriverObject->MajorFunction[IRP_MJ_CLOSE] = CloseSoundBlaster;
 480     DriverObject->MajorFunction[IRP_MJ_CLEANUP] = CleanupSoundBlaster;
 481     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ControlSoundBlaster;
 482     DriverObject->MajorFunction[IRP_MJ_WRITE] = WriteSoundBlaster;
 483     DriverObject->DriverUnload = UnloadSoundBlaster;
 484
 485     DPRINT("Beginning device key enumeration\n");
 486
 487     status = EnumerateDeviceKeys(RegistryPath, *InitializeSoundBlaster, DriverObject);
 488
 489     return status;
 490 }