[APPHELP_APITEST] Add tests for SdbGetMatchingExe, to test matching on version resour...
[reactos.git] / reactos / drivers / multimedia / audio / sndblst.old / sndblst.c
1 /*
2 *
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS kernel
5 * FILE: services/dd/sndblst/sndblst.c
6 * PURPOSE: Sound Blaster / SB Pro / SB 16 driver
7 * PROGRAMMER: Andrew Greenwood
8 * UPDATE HISTORY:
9 * Sept 28, 2003: Copied from mpu401.c as a template
10 */
11
12 /* INCLUDES ****************************************************************/
13
14 #include <ntddk.h>
15 #include "sndblst.h"
16
17 NTSTATUS NTAPI
18 DriverEntry(PDRIVER_OBJECT DriverObject,
19 PUNICODE_STRING RegistryPath);
20
21 /* INTERNAL VARIABLES ******************************************************/
22
23 ULONG DeviceCount = 0;
24
25
26 /* FUNCTIONS ***************************************************************/
27
28 static NTSTATUS InitDevice(
29 IN PWSTR RegistryPath,
30 IN PVOID Context)
31 {
32 // PDEVICE_INSTANCE Instance = Context;
33 PDEVICE_OBJECT DeviceObject; // = Context;
34 PDEVICE_EXTENSION Parameters; // = DeviceObject->DeviceExtension;
35 UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Device\\WaveOut0"); // CHANGE THESE?
36 UNICODE_STRING SymlinkName = RTL_CONSTANT_STRING(L"\\??\\WaveOut0");
37
38 // CONFIG Config;
39 RTL_QUERY_REGISTRY_TABLE Table[2];
40 NTSTATUS s;
41 USHORT DSP_Version = 0;
42 UCHAR DSP_Major = 0, DSP_Minor = 0;
43
44 // This is TEMPORARY, to ensure that we don't process more than 1 device.
45 // This limitation should be removed in future.
46 if (DeviceCount > 0)
47 {
48 DPRINT("Sorry - only 1 device supported by Sound Blaster driver at present :(\n");
49 return STATUS_NOT_IMPLEMENTED;
50 }
51
52 DPRINT("Creating IO device\n");
53
54 s = IoCreateDevice(Context, // driverobject
55 sizeof(DEVICE_EXTENSION),
56 &DeviceName,
57 FILE_DEVICE_SOUND, // Correct?
58 0,
59 FALSE,
60 &DeviceObject);
61
62 if (!NT_SUCCESS(s))
63 return s;
64
65 DPRINT("Device Extension at 0x%x\n", DeviceObject->DeviceExtension);
66 Parameters = DeviceObject->DeviceExtension;
67
68 DPRINT("Creating DOS link\n");
69
70 /* Create the dos device link */
71 s = IoCreateSymbolicLink(&SymlinkName,
72 &DeviceName);
73
74 if (!NT_SUCCESS(s))
75 {
76 IoDeleteDevice(DeviceObject);
77 return s;
78 }
79
80 DPRINT("Initializing device\n");
81
82 // DPRINT("Allocating memory for parameters structure\n");
83 // Bodged:
84 // Parameters = (PDEVICE_EXTENSION)ExAllocatePool(NonPagedPool, sizeof(DEVICE_EXTENSION));
85 // DeviceObject->DeviceExtension = Parameters;
86 // Parameters = Instance->DriverObject->DriverExtension;
87
88 DPRINT("DeviceObject at 0x%x, DeviceExtension at 0x%x\n", DeviceObject, Parameters);
89
90 if (! Parameters)
91 {
92 DPRINT("NULL POINTER!\n");
93 return STATUS_INSUFFICIENT_RESOURCES;
94 }
95
96 // Instance->DriverObject->DriverExtension = Parameters;
97
98 DPRINT("Setting reg path\n");
99 Parameters->RegistryPath = RegistryPath;
100 // Parameters->DriverObject = Instance->DriverObject;
101
102 DPRINT("Zeroing table memory and setting query routine\n");
103 RtlZeroMemory(Table, sizeof(Table));
104 Table[0].QueryRoutine = LoadSettings;
105
106 DPRINT("Setting port and IRQ defaults\n");
107 Parameters->Port = DEFAULT_PORT;
108 Parameters->IRQ = DEFAULT_IRQ;
109 Parameters->DMA = DEFAULT_DMA;
110 Parameters->BufferSize = DEFAULT_BUFSIZE;
111
112 // Only to be enabled once we can get support for multiple cards working :)
113 /*
114 DPRINT("Loading settings from: %S\n", RegistryPath);
115
116 s = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE, RegistryPath, Table,
117 &Parameters, NULL);
118
119 if (! NT_SUCCESS(s))
120 return s;
121 */
122
123 DPRINT("Port 0x%x IRQ %d DMA %d\n", Parameters->Port, Parameters->IRQ, Parameters->DMA);
124
125 // Instance->P
126
127 // Initialize the card
128 DSP_Version = InitSoundCard(Parameters->Port);
129 if (! DSP_Version)
130 {
131 DPRINT("Sound card initialization FAILED!\n");
132 // Set state indication somehow
133 // Failure - what error code do we give?!
134 // return STATUS_????
135 IoDeleteDevice(DeviceObject);
136 return STATUS_UNSUCCESSFUL;
137 }
138
139 DSP_Major = DSP_Version / 256;
140 DSP_Minor = DSP_Version % 256;
141
142 // Do stuff related to version here...
143
144 DPRINT("Allocating DMA\n");
145 if (! CreateDMA(DeviceObject))
146 DPRINT("FAILURE!\n");
147
148 // TEMPORARY TESTING STUFF: should be in BlasterCreate
149 EnableSpeaker(Parameters->Port, TRUE);
150 SetOutputSampleRate(Parameters->Port, 2205);
151 BeginPlayback(Parameters->Port, 16, 2, Parameters->BufferSize);
152
153 DeviceCount ++;
154
155 return STATUS_SUCCESS;
156 }
157
158
159 static NTSTATUS NTAPI
160 BlasterCreate(PDEVICE_OBJECT DeviceObject,
161 PIRP Irp)
162 /*
163 * FUNCTION: Handles user mode requests
164 * ARGUMENTS:
165 * DeviceObject = Device for request
166 * Irp = I/O request packet describing request
167 * RETURNS: Success or failure
168 */
169 {
170 DPRINT("BlasterCreate() called!\n");
171
172 // Initialize the MPU-401
173 // ... do stuff ...
174
175
176 // Play a note to say we're alive:
177 // WaitToSend(MPU401_PORT);
178 // MPU401_WRITE_DATA(MPU401_PORT, 0x90);
179 // WaitToSend(MPU401_PORT);
180 // MPU401_WRITE_DATA(MPU401_PORT, 0x50);
181 // WaitToSend(MPU401_PORT);
182 // MPU401_WRITE_DATA(MPU401_PORT, 0x7f);
183
184 Irp->IoStatus.Status = STATUS_SUCCESS;
185 Irp->IoStatus.Information = 0;
186
187 DPRINT("IoCompleteRequest()\n");
188
189 IoCompleteRequest(Irp,
190 IO_NO_INCREMENT);
191
192 DPRINT("BlasterCreate() completed\n");
193
194 return(STATUS_SUCCESS);
195 }
196
197
198 static NTSTATUS NTAPI
199 BlasterClose(PDEVICE_OBJECT DeviceObject,
200 PIRP Irp)
201 /*
202 * FUNCTION: Handles user mode requests
203 * ARGUMENTS:
204 * DeviceObject = Device for request
205 * Irp = I/O request packet describing request
206 * RETURNS: Success or failure
207 */
208 {
209 PDEVICE_EXTENSION DeviceExtension;
210 NTSTATUS Status;
211
212 DPRINT("BlasterClose() called!\n");
213
214 DeviceExtension = DeviceObject->DeviceExtension;
215
216 Status = STATUS_SUCCESS;
217
218 Irp->IoStatus.Status = Status;
219 Irp->IoStatus.Information = 0;
220 IoCompleteRequest(Irp,
221 IO_NO_INCREMENT);
222
223 return(Status);
224 }
225
226
227 static NTSTATUS NTAPI
228 BlasterCleanup(PDEVICE_OBJECT DeviceObject,
229 PIRP Irp)
230 /*
231 * FUNCTION: Handles user mode requests
232 * ARGUMENTS:
233 * DeviceObject = Device for request
234 * Irp = I/O request packet describing request
235 * RETURNS: Success or failure
236 */
237 {
238 ULONG Channel;
239 DPRINT("BlasterCleanup() called!\n");
240
241 // Reset the device (should we do this?)
242 for (Channel = 0; Channel <= 15; Channel ++)
243 {
244 // All notes off
245 // MPU401_WRITE_MESSAGE(MPU401_PORT, 0xb0 + Channel, 123, 0);
246 // All controllers off
247 // MPU401_WRITE_MESSAGE(MPU401_PORT, 0xb0 + Channel, 121, 0);
248 }
249
250
251 Irp->IoStatus.Status = STATUS_SUCCESS;
252 Irp->IoStatus.Information = 0;
253 IoCompleteRequest(Irp,
254 IO_NO_INCREMENT);
255
256 return(STATUS_SUCCESS);
257 }
258
259
260 static NTSTATUS NTAPI
261 BlasterWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp)
262 {
263 PIO_STACK_LOCATION Stack;
264 PDEVICE_EXTENSION DeviceExtension;
265 ULONG ByteCount;
266 PUCHAR Data;
267
268 DPRINT("BlasterWrite() called!\n");
269
270 DeviceExtension = DeviceObject->DeviceExtension;
271 Stack = IoGetCurrentIrpStackLocation(Irp);
272
273 DPRINT("%d bytes\n", Stack->Parameters.Write.Length);
274
275 Data = (PUCHAR) Irp->AssociatedIrp.SystemBuffer;
276
277 for (ByteCount = 0; ByteCount < Stack->Parameters.Write.Length; ByteCount ++)
278 {
279 // DPRINT("0x%x ", Data[ByteCount]);
280
281 // MPU401_WRITE_BYTE(DeviceExtension->Port, Data[ByteCount]);
282 }
283
284 Irp->IoStatus.Status = STATUS_SUCCESS;
285 Irp->IoStatus.Information = 0;
286 IoCompleteRequest(Irp,
287 IO_NO_INCREMENT);
288
289 return(STATUS_SUCCESS);
290 }
291
292
293 static NTSTATUS NTAPI
294 BlasterDeviceControl(PDEVICE_OBJECT DeviceObject,
295 PIRP Irp)
296 /*
297 * FUNCTION: Handles user mode requests
298 * ARGUMENTS:
299 * DeviceObject = Device for request
300 * Irp = I/O request packet describing request
301 * RETURNS: Success or failure
302 */
303 {
304 PIO_STACK_LOCATION Stack;
305 PDEVICE_EXTENSION DeviceExtension;
306
307 DPRINT("BlasterDeviceControl() called!\n");
308
309 DeviceExtension = DeviceObject->DeviceExtension;
310 Stack = IoGetCurrentIrpStackLocation(Irp);
311
312 switch(Stack->Parameters.DeviceIoControl.IoControlCode)
313 {
314 /* case IOCTL_MIDI_PLAY :
315 {
316 DPRINT("Received IOCTL_MIDI_PLAY\n");
317 Data = (PUCHAR) Irp->AssociatedIrp.SystemBuffer;
318
319 DPRINT("Sending %d bytes of MIDI data to 0x%x:\n", Stack->Parameters.DeviceIoControl.InputBufferLength, DeviceExtension->Port);
320
321 for (ByteCount = 0; ByteCount < Stack->Parameters.DeviceIoControl.InputBufferLength; ByteCount ++)
322 {
323 DPRINT("0x%x ", Data[ByteCount]);
324
325 MPU401_WRITE_BYTE(DeviceExtension->Port, Data[ByteCount]);
326 // if (WaitToSend(MPU401_PORT))
327 // MPU401_WRITE_DATA(MPU401_PORT, Data[ByteCount]);
328 }
329
330 Irp->IoStatus.Status = STATUS_SUCCESS;
331 IoCompleteRequest(Irp, IO_NO_INCREMENT);
332
333 return(STATUS_SUCCESS);
334 }
335 */
336 }
337
338 return(STATUS_SUCCESS);
339
340 /*
341 DeviceExtension = DeviceObject->DeviceExtension;
342 Stack = IoGetCurrentIrpStackLocation(Irp);
343 BeepParam = (PBEEP_SET_PARAMETERS)Irp->AssociatedIrp.SystemBuffer;
344
345 Irp->IoStatus.Information = 0;
346
347 if (Stack->Parameters.DeviceIoControl.IoControlCode != IOCTL_BEEP_SET)
348 {
349 Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
350 IoCompleteRequest(Irp,
351 IO_NO_INCREMENT);
352 return(STATUS_NOT_IMPLEMENTED);
353 }
354
355 if ((Stack->Parameters.DeviceIoControl.InputBufferLength != sizeof(BEEP_SET_PARAMETERS))
356 || (BeepParam->Frequency < BEEP_FREQUENCY_MINIMUM)
357 || (BeepParam->Frequency > BEEP_FREQUENCY_MAXIMUM))
358 {
359 Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
360 IoCompleteRequest(Irp,
361 IO_NO_INCREMENT);
362 return(STATUS_INVALID_PARAMETER);
363 }
364
365 DueTime.QuadPart = 0;
366 */
367 /* do the beep!! */
368 /* DPRINT("Beep:\n Freq: %lu Hz\n Dur: %lu ms\n",
369 pbsp->Frequency,
370 pbsp->Duration);
371
372 if (BeepParam->Duration >= 0)
373 {
374 DueTime.QuadPart = (LONGLONG)BeepParam->Duration * -10000;
375
376 KeSetTimer(&DeviceExtension->Timer,
377 DueTime,
378 &DeviceExtension->Dpc);
379
380 HalMakeBeep(BeepParam->Frequency);
381 DeviceExtension->BeepOn = TRUE;
382 KeWaitForSingleObject(&DeviceExtension->Event,
383 Executive,
384 KernelMode,
385 FALSE,
386 NULL);
387 }
388 else if (BeepParam->Duration == (DWORD)-1)
389 {
390 if (DeviceExtension->BeepOn == TRUE)
391 {
392 HalMakeBeep(0);
393 DeviceExtension->BeepOn = FALSE;
394 }
395 else
396 {
397 HalMakeBeep(BeepParam->Frequency);
398 DeviceExtension->BeepOn = TRUE;
399 }
400 }
401
402 DPRINT("Did the beep!\n");
403
404 Irp->IoStatus.Status = STATUS_SUCCESS;
405 IoCompleteRequest(Irp,
406 IO_NO_INCREMENT);
407 return(STATUS_SUCCESS);
408 */
409 }
410
411
412 static VOID NTAPI
413 BlasterUnload(PDRIVER_OBJECT DriverObject)
414 {
415 DPRINT("BlasterUnload() called!\n");
416 }
417
418
419 NTSTATUS NTAPI
420 DriverEntry(PDRIVER_OBJECT DriverObject,
421 PUNICODE_STRING RegistryPath)
422 /*
423 * FUNCTION: Called by the system to initialize the driver
424 * ARGUMENTS:
425 * DriverObject = object describing this driver
426 * RegistryPath = path to our configuration entries
427 * RETURNS: Success or failure
428 */
429 {
430 // PDEVICE_EXTENSION DeviceExtension;
431 // PDEVICE_OBJECT DeviceObject;
432 // DEVICE_INSTANCE Instance;
433 // Doesn't support multiple instances (yet ...)
434 NTSTATUS Status;
435
436 DPRINT("Sound Blaster Device Driver 0.0.2\n");
437
438 // Instance.DriverObject = DriverObject;
439 // previous instance = NULL...
440
441 // DeviceExtension->RegistryPath = RegistryPath;
442
443 DriverObject->Flags = 0;
444 DriverObject->MajorFunction[IRP_MJ_CREATE] = BlasterCreate;
445 DriverObject->MajorFunction[IRP_MJ_CLOSE] = BlasterClose;
446 DriverObject->MajorFunction[IRP_MJ_CLEANUP] = BlasterCleanup;
447 DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = BlasterDeviceControl;
448 DriverObject->MajorFunction[IRP_MJ_WRITE] = BlasterWrite;
449 DriverObject->DriverUnload = BlasterUnload;
450
451 // Major hack to just get this damn thing working:
452 Status = InitDevice(RegistryPath->Buffer, DriverObject); // ????
453
454 // DPRINT("Enumerating devices at %wZ\n", RegistryPath);
455
456 // Status = EnumDeviceKeys(RegistryPath, PARMS_SUBKEY, InitDevice, (PVOID)&DeviceObject); // &Instance;
457
458 // check error
459
460 /* set up device extension */
461 // DeviceExtension = DeviceObject->DeviceExtension;
462 // DeviceExtension->BeepOn = FALSE;
463
464 // return(STATUS_SUCCESS);
465 return(Status);
466 }
467
468 /* EOF */