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 }
491