![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to soundlib.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / mmedia / soundlib|
Return to soundlib.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / mmedia / soundlib |
1.1 root 1: /*++
2:
3: Copyright (c) 1992 Microsoft Corporation
4:
5: Module Name:
6:
7: soundlib.c
8:
9: Abstract:
10:
11: This module contains common code for Sound Kernel mode device
12: drivers.
13:
14: Author:
15:
16: Robin Speed (robinsp) 16-October-1992
17:
18: Environment:
19:
20: Kernel mode
21:
22: Revision History:
23:
24:
25: --*/
26:
27: #include <string.h>
28: #include <stdlib.h>
29: #include <stdio.h> // For vsprintf
30: #include <stdarg.h> // For va_list
31: #include <soundlib.h> // Definition of what's in here
32:
33: //
34: // Internal routine definintions
35: //
36:
37: NTSTATUS SoundConfigurationCallout(
38: IN PVOID Context,
39: IN PUNICODE_STRING PathName,
40: IN INTERFACE_TYPE BusType,
41: IN ULONG BusNumber,
42: IN PKEY_VALUE_FULL_INFORMATION *BusInformation,
43: IN CONFIGURATION_TYPE ControllerType,
44: IN ULONG ControllerNumber,
45: IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation,
46: IN CONFIGURATION_TYPE PeripheralType,
47: IN ULONG PeripheralNumber,
48: IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation
49: );
50:
51: //
52: // Remove initialization stuff from resident memory
53: //
54:
55: #ifdef ALLOC_PRAGMA
56: #pragma alloc_text(init,SoundGetBusNumber)
57: #pragma alloc_text(init,SoundConfigurationCallout)
58: #pragma alloc_text(init,SoundReportResourceUsage)
59: #pragma alloc_text(init,SoundCreateDevice)
60: #pragma alloc_text(init,SoundMapPortAddress)
61: #pragma alloc_text(init,SoundConnectInterrupt)
62: #pragma alloc_text(init,SoundSetErrorCode)
63: #pragma alloc_text(init,SoundSaveRegistryPath)
64: #endif
65:
66:
67: NTSTATUS
68: SoundGetBusNumber(
69: IN OUT INTERFACE_TYPE InterfaceType,
70: OUT PULONG BusNumber
71: )
72: /*++
73:
74: Routine Description :
75:
76: Find the bus of the type we are looking for - and hope this is
77: the one with our card on! Actually if bus is not
78: bus number 0 we fail.
79:
80: Arguments :
81:
82: BusNumber - Where to put the answer
83:
84: Return Value :
85:
86: NT status code - STATUS_SUCCESS if no problems
87:
88: --*/
89: {
90: ULONG TestBusNumber = 0;
91: NTSTATUS Status;
92: BOOLEAN Ok = FALSE; // Must match type passed by reference to
93: // SoundConfigurationCallout by
94: // IoQueryDeviceDescription.
95:
96: //
97: // See if our bus type exists by calling IoQueryDeviceDescription
98: //
99:
100:
101: Status = IoQueryDeviceDescription(
102: &InterfaceType,
103: &TestBusNumber,
104: NULL,
105: NULL,
106: NULL,
107: NULL,
108: SoundConfigurationCallout,
109: (PVOID)&Ok);
110:
111:
112: if (Ok) {
113: *BusNumber = TestBusNumber;
114: }
115:
116: return Ok ? STATUS_SUCCESS : STATUS_DEVICE_DOES_NOT_EXIST;
117: }
118:
119:
120:
121:
122: NTSTATUS
123: SoundConfigurationCallout(
124: IN PVOID Context,
125: IN PUNICODE_STRING PathName,
126: IN INTERFACE_TYPE BusType,
127: IN ULONG BusNumber,
128: IN PKEY_VALUE_FULL_INFORMATION *BusInformation,
129: IN CONFIGURATION_TYPE ControllerType,
130: IN ULONG ControllerNumber,
131: IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation,
132: IN CONFIGURATION_TYPE PeripheralType,
133: IN ULONG PeripheralNumber,
134: IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation
135: )
136: /*++
137:
138: Routine Description :
139:
140: Set the return to OK to indicate we've found the bus type
141: we were looking for. Merely being called is confirmation
142: that our bus is there.
143:
144: Arguments :
145:
146: See the arguments defined by PIO_QUERY_DEVICE_ROUTINE
147:
148: Return Value :
149:
150: STATUS_SUCCESS if no problems
151:
152: --*/
153: {
154: *(PBOOLEAN)Context = (BOOLEAN)TRUE;
155: return STATUS_SUCCESS;
156: }
157:
158:
159:
160:
161: NTSTATUS SoundReportResourceUsage(
162: IN PDEVICE_OBJECT DeviceObject,
163: IN INTERFACE_TYPE BusType,
164: IN ULONG BusNumber,
165: IN PULONG InterruptNumber OPTIONAL,
166: IN KINTERRUPT_MODE InterruptMode,
167: IN BOOLEAN InterruptShareDisposition,
168: IN PULONG DmaChannel OPTIONAL,
169: IN PULONG FirstIoPort OPTIONAL,
170: IN ULONG IoPortLength
171: )
172: /*++
173:
174: Routine Description :
175:
176: Calls IoReportResourceUsage for the device and resources
177: passed in. NOTE that this supercedes previous resources
178: declared for this device.
179:
180: It is assumed that all resources owned by the device cannot
181: be shared, except for level-sensitive interrupts which can be
182: shared.
183:
184: Arguments :
185:
186: DeviceObject - The device which 'owns' the resources
187: This can also be a pointer to a driver object
188: BusType - The type of bus on which the device lives
189: BusNumber - The bus number (of type BusType) where the device is
190: InterruptNumber - The interrupt the devices uses (if any)
191: DmaChannel - The DMA channel the device uses
192: FirstIoPort - The start Io port for the device
193: IoPortLength - The number of bytes of IO space the device uses
194: (starting at FirstIoPort)
195:
196: Return Value :
197:
198: STATUS_SUCCESS if no problems
199: The return from IoReportResourceUsage if this fails
200: STATUS_DEVICE_CONFIGURATION_ERROR is IoReportResourceUsage reports
201: a conflict
202:
203: --*/
204:
205: {
206: NTSTATUS Status;
207:
208: //
209: // Our resource list to report back to the system
210: //
211:
212: /*
213:
214: Compiler rejects this
215:
216: UCHAR ResBuffer[FIELD_OFFSET(
217: CM_RESOURCE_LIST,
218: List[0].PartialResourceList.PartialDescriptors[3].Type)];
219:
220: */
221:
222: UCHAR ResBuffer[3 * sizeof(CM_RESOURCE_LIST)];
223:
224: BOOLEAN ResourceConflict;
225:
226: PCM_RESOURCE_LIST ResourceList;
227: PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
228:
229: ResourceList = (PCM_RESOURCE_LIST)ResBuffer;
230: Descriptor = ResourceList->List[0].PartialResourceList.PartialDescriptors;
231: ResourceConflict = FALSE;
232:
233: //
234: // Zero out any unused data
235: //
236:
237: RtlZeroMemory(ResBuffer, sizeof(ResBuffer));
238:
239: //
240: // We assume there's only 1 bus so we only need one list.
241: // Fill in the bus description
242: //
243:
244: ResourceList->Count = 1;
245: ResourceList->List[0].InterfaceType = BusType;
246: ResourceList->List[0].BusNumber = BusNumber;
247:
248: //
249: // If the device is using IO Ports add this to the list
250: //
251:
252: if (ARGUMENT_PRESENT(FirstIoPort)) {
253: PHYSICAL_ADDRESS PortAddress;
254: ULONG MemType;
255: PHYSICAL_ADDRESS MappedAddress;
256:
257: PortAddress.LowPart = *FirstIoPort;
258: PortAddress.HighPart = 0;
259: MemType = 1;
260:
261: HalTranslateBusAddress(
262: BusType,
263: BusNumber,
264: PortAddress,
265: &MemType,
266: &MappedAddress);
267:
268:
269: ResourceList->List[0].PartialResourceList.Count++;
270:
271: Descriptor->Type = CmResourceTypePort;
272:
273: Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
274:
275: Descriptor->u.Port.Start.LowPart = *FirstIoPort;
276:
277: Descriptor->u.Port.Length = IoPortLength;
278:
279: Descriptor->Flags = MemType == 0 ? CM_RESOURCE_PORT_MEMORY :
280: CM_RESOURCE_PORT_IO;
281:
282: //
283: // Move on to next resource descriptor entry
284: //
285:
286: Descriptor++;
287: }
288:
289: //
290: // Add interrupt information (if any) to the list
291: //
292:
293: if (ARGUMENT_PRESENT(InterruptNumber)) {
294: ResourceList->List[0].PartialResourceList.Count++;
295:
296: Descriptor->Type = CmResourceTypeInterrupt;
297:
298: Descriptor->ShareDisposition = InterruptShareDisposition ?
299: CmResourceShareShared :
300: CmResourceShareDeviceExclusive;
301:
302: Descriptor->Flags =
303: InterruptMode == Latched ? CM_RESOURCE_INTERRUPT_LATCHED :
304: CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE;
305:
306: Descriptor->u.Interrupt.Level = *InterruptNumber;
307:
308: Descriptor->u.Interrupt.Vector = *InterruptNumber;
309:
310: //
311: // Move on to next resource descriptor entry
312: //
313:
314: Descriptor++;
315: }
316:
317: //
318: // Add DMA description if any
319: //
320:
321: if (ARGUMENT_PRESENT(DmaChannel)) {
322: ResourceList->List[0].PartialResourceList.Count++;
323:
324: Descriptor->Type = CmResourceTypeDma;
325:
326: Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
327:
328: Descriptor->u.Dma.Channel = *DmaChannel;
329:
330: Descriptor->u.Dma.Port = 0; // ???
331:
332: //
333: // Move on to next resource descriptor entry
334: //
335:
336: Descriptor++;
337: }
338:
339: //
340: // Report our resource usage and detect conflicts
341: //
342:
343: switch (DeviceObject->Type) {
344: case IO_TYPE_DEVICE:
345: Status = IoReportResourceUsage(NULL,
346: DeviceObject->DriverObject,
347: NULL,
348: 0,
349: DeviceObject,
350: ResourceList,
351: (PUCHAR)Descriptor - (PUCHAR)ResourceList,
352: FALSE,
353: &ResourceConflict);
354: break;
355: case IO_TYPE_DRIVER:
356: Status = IoReportResourceUsage(NULL,
357: (PDRIVER_OBJECT)DeviceObject,
358: ResourceList,
359: (PUCHAR)Descriptor - (PUCHAR)ResourceList,
360: NULL,
361: NULL,
362: 0,
363: FALSE,
364: &ResourceConflict);
365: break;
366:
367: default:
368: ASSERTMSG("SoundReportResourceUsage - invalid object", FALSE);
369: }
370:
371: if (ResourceConflict) {
372: dprintf1(("Resource conflict reported"));
373: Status = STATUS_DEVICE_CONFIGURATION_ERROR;
374: }
375:
376: return Status;
377: }
378:
379:
380:
381:
382: VOID
383: SoundFreeDevice(
384: IN PDEVICE_OBJECT DeviceObject
385: )
386: /*++
387:
388: Routine Description :
389:
390: Free the all resources related to this device :
391:
392: The device object itself
393:
394: Any declared hardware resources (via IoReportResourceUsage)
395:
396: Any symbolic link related to this device
397:
398: Arguments :
399:
400: DeviceObject - the device to free
401:
402: Return Value :
403:
404: None
405:
406: --*/
407: {
408: CM_RESOURCE_LIST NullResourceList;
409: BOOLEAN ResourceConflict;
410:
411:
412: //
413: // Free the device if any
414: //
415:
416: if (DeviceObject != NULL) {
417:
418:
419: //
420: // Undeclare any resources used by the device
421: // (delete anything the driver has at the same time!)
422: //
423:
424: NullResourceList.Count = 0;
425:
426: IoReportResourceUsage(NULL,
427: DeviceObject->DriverObject,
428: &NullResourceList,
429: sizeof(ULONG),
430: DeviceObject,
431: &NullResourceList,
432: sizeof(ULONG),
433: FALSE,
434: &ResourceConflict);
435:
436: //
437: // Remove the device's symbolic link
438: //
439:
440: {
441: PLOCAL_DEVICE_INFO pLDI;
442: UNICODE_STRING DeviceName;
443: WCHAR Number[8];
444: WCHAR TestName[SOUND_MAX_DEVICE_NAME];
445:
446: pLDI = DeviceObject->DeviceExtension;
447:
448: DeviceName.Buffer = TestName;
449: DeviceName.MaximumLength = sizeof(TestName);
450: DeviceName.Length = 0;
451:
452: RtlAppendUnicodeToString(&DeviceName, L"\\DosDevices");
453:
454: RtlAppendUnicodeToString(
455: &DeviceName,
456: pLDI->DeviceInit->PrototypeName +
457: (sizeof(L"\\Device") - sizeof(UNICODE_NULL)) /
458: sizeof(UNICODE_NULL));
459:
460: if (!(pLDI->CreationFlags & SOUND_CREATION_NO_NAME_RANGE)) {
461: UNICODE_STRING UnicodeNum;
462: WCHAR Number[8];
463: UnicodeNum.MaximumLength = sizeof(Number);
464: UnicodeNum.Buffer = Number;
465:
466: RtlIntegerToUnicodeString(pLDI->DeviceNumber, 10, &UnicodeNum);
467: RtlAppendUnicodeStringToString(&DeviceName, &UnicodeNum);
468: }
469:
470: IoDeleteSymbolicLink(&DeviceName);
471: }
472:
473: //
474: // Delete the device object
475: //
476:
477: IoDeleteDevice(DeviceObject);
478: }
479: }
480:
481:
482: NTSTATUS
483: SoundCreateDevice(
484: IN PSOUND_DEVICE_INIT DeviceInit,
485: IN UCHAR CreationFlags,
486: IN PDRIVER_OBJECT pDriverObject,
487: IN PVOID pGDI,
488: IN PVOID DeviceSpecificData,
489: IN PVOID pHw,
490: IN int i,
491: OUT PDEVICE_OBJECT *ppDevObj
492: )
493:
494: /*++
495:
496: Routine Description:
497:
498: Create a new device using a name derived from szPrototypeName
499: by adding a number on to the end such that the no device with the
500: qualified name exists.
501:
502: A symbolic link in \DosDevices is also created
503:
504: Arguments:
505:
506: DeviceInit - device initialization data
507:
508: NoRange - if this is set then no number is concatenated, the
509: explicit name is used.
510:
511: pDriverObject - our driver
512:
513: pGDI - global context
514:
515: pHw - hardware context
516:
517: i - device number for back reference
518:
519: ppDevObj - where to write back the device object pointer
520:
521: Return Value:
522:
523: An NTSTATUS code.
524:
525: --*/
526:
527: {
528:
529: int DeviceNumber;
530: NTSTATUS Status;
531: UNICODE_STRING DeviceName;
532: UNICODE_STRING UnicodeNum;
533: WCHAR TestName[SOUND_MAX_DEVICE_NAME];
534: WCHAR Number[8];
535: OBJECT_ATTRIBUTES ObjectAttributes;
536: PLOCAL_DEVICE_INFO pLDI;
537:
538: #ifdef SOUND_DIRECTORIES
539: HANDLE DirectoryHandle = NULL;
540:
541: //
542: // Create the directory for this device type.
543: //
544:
545: RtlInitUnicodeString(&DeviceName, DeviceInit->PrototypeName);
546: InitializeObjectAttributes(&ObjectAttributes,
547: &DeviceName,
548: OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
549: NULL,
550: (PSECURITY_DESCRIPTOR)NULL);
551:
552: //
553: // We create the directory if it doesn't exist.
554: // We must keep this handle open until we create something as
555: // we're not making it permanent. This means that if we unload
556: // the system may be able to get rid of the directory
557: //
558:
559: Status = ZwCreateDirectoryObject(&DirectoryHandle,
560: GENERIC_READ,
561: &ObjectAttributes);
562:
563: if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_COLLISION) {
564: dprintf1(("Return code from NtCreateDirectoryObject = %x", Status));
565: return Status;
566: } else {
567: //
568: // Directory is permanent so it won't go away.
569: //
570: ZwClose(DirectoryHandle);
571: }
572: #endif // SOUND_DIRECTORIES
573:
574: for (DeviceNumber = 0; DeviceNumber < SOUND_MAX_DEVICES; DeviceNumber ++) {
575:
576: //
577: // Create our test name
578: //
579:
580: DeviceName.Length = 0;
581: DeviceName.Buffer = TestName;
582: DeviceName.MaximumLength = sizeof(TestName);
583:
584: Status = RtlAppendUnicodeToString(&DeviceName, DeviceInit->PrototypeName);
585:
586: if (!NT_SUCCESS(Status)) {
587: return Status;
588: }
589:
590: #ifdef SOUND_DIRECTORIES
591: RtlAppendUnicodeToString(&DeviceName, "\\");
592: #else
593: #endif // SOUND_DIRECTORIES
594:
595: //
596: // Append the device number if required
597: //
598:
599: if (!(CreationFlags & SOUND_CREATION_NO_NAME_RANGE)) {
600: UnicodeNum.MaximumLength = sizeof(Number);
601: UnicodeNum.Buffer = Number;
602: RtlIntegerToUnicodeString(DeviceNumber, 10, &UnicodeNum);
603:
604: RtlAppendUnicodeStringToString(&DeviceName, &UnicodeNum);
605: } else {
606: DeviceNumber = 255;
607: }
608:
609: Status = IoCreateDevice(
610: pDriverObject,
611: sizeof(LOCAL_DEVICE_INFO),
612: &DeviceName,
613: DeviceInit->Type,
614: 0,
615: FALSE, // Non-Exclusive
616: ppDevObj
617: );
618:
619: if (NT_SUCCESS(Status)) {
620: dprintf2(("Created device %d", DeviceNumber));
621:
622: //
623: // Set up the rest of the device stuff
624: //
625:
626: (*ppDevObj)->Flags |= DeviceInit->IoMethod;
627: (*ppDevObj)->AlignmentRequirement = FILE_BYTE_ALIGNMENT;
628:
629: if (DeviceInit->DeferredRoutine) {
630: IoInitializeDpcRequest((*ppDevObj), DeviceInit->DeferredRoutine);
631: }
632:
633: pLDI = (*ppDevObj)->DeviceExtension;
634: RtlZeroMemory(pLDI, sizeof(*pLDI));
635:
636: //
637: // Try to create a symbolic link object for this device
638: //
639: // No security
640: //
641: // We make (eg)
642: // \DosDevices\WaveOut0
643: // Point to
644: // \Device\WaveOut0
645: //
646:
647: {
648: UNICODE_STRING LinkObject;
649: WCHAR LinkName[80];
650: ULONG DeviceSize;
651:
652: LinkName[0] = UNICODE_NULL;
653:
654: RtlInitUnicodeString(&LinkObject, LinkName);
655:
656: LinkObject.MaximumLength = sizeof(LinkName);
657:
658: RtlAppendUnicodeToString(&LinkObject, L"\\DosDevices");
659:
660: DeviceSize = sizeof(L"\\Device") - sizeof(UNICODE_NULL);
661: DeviceName.Buffer += DeviceSize / sizeof(WCHAR);
662: DeviceName.Length -= DeviceSize;
663:
664: RtlAppendUnicodeStringToString(&LinkObject, &DeviceName);
665:
666: DeviceName.Buffer -= DeviceSize / sizeof(WCHAR);
667: DeviceName.Length += DeviceSize;
668:
669: Status = IoCreateSymbolicLink(&LinkObject, &DeviceName);
670:
671: if (!NT_SUCCESS(Status)) {
672: dprintf1(("Failed to create symbolic link object"));
673: IoDeleteDevice(*ppDevObj);
674: *ppDevObj = NULL;
675: return Status;
676: }
677: }
678:
679: //
680: // Fill in the rest of the device information
681: //
682:
683: #ifdef VOLUME_NOTIFY
684: InitializeListHead(&pLDI->VolumeQueue);
685: #endif // VOLUME_NOTIFY
686:
687: pLDI->DeviceNumber = DeviceNumber;
688: pLDI->DeviceInit = DeviceInit;
689: pLDI->CreationFlags = CreationFlags;
690:
691: pLDI->Key = *(PULONG)DeviceInit->Key;
692: pLDI->DeviceType = DeviceInit->DeviceType;
693: pLDI->DeviceIndex = (UCHAR)i;
694: pLDI->pGlobalInfo = pGDI;
695: pLDI->DeviceSpecificData = DeviceSpecificData;
696: pLDI->HwContext = pHw;
697:
698: return STATUS_SUCCESS;
699: }
700: }
701: //
702: // Failed !
703: //
704:
705: return STATUS_INSUFFICIENT_RESOURCES;
706: }
707:
708:
709:
710:
711: PUCHAR
712: SoundMapPortAddress(
713: INTERFACE_TYPE BusType,
714: ULONG BusNumber,
715: ULONG PortBase,
716: ULONG Length,
717: PULONG MemType
718: )
719: /*++
720:
721: Routine Description :
722:
723: Map a physical device port address to an address we can pass
724: to READ/WRITE_PORT_UCHAR/USHORT etc
725:
726: Arguments :
727: BusType - type of bus
728: BusNumber - bus number
729: PortBase - The port start address
730: Length - how many bytes of port space to map (needed by MmMapIoSpace)
731:
732: Return Value :
733:
734: The virtual port address
735:
736: --*/
737: {
738: PHYSICAL_ADDRESS PortAddress;
739: PHYSICAL_ADDRESS MappedAddress;
740:
741: *MemType = 1; // IO space
742: PortAddress.LowPart = PortBase;
743: PortAddress.HighPart = 0;
744: HalTranslateBusAddress(
745: BusType,
746: BusNumber,
747: PortAddress,
748: MemType,
749: &MappedAddress);
750:
751: if (*MemType == 0) {
752: //
753: // Map memory type IO space into our address space
754: //
755: return (PUCHAR)MmMapIoSpace(MappedAddress, Length, FALSE);
756: } else {
757: return (PUCHAR)MappedAddress.LowPart;
758: }
759: }
760:
761:
762:
763: NTSTATUS
764: SoundConnectInterrupt(
765: IN ULONG InterruptNumber,
766: IN INTERFACE_TYPE BusType,
767: IN ULONG BusNumber,
768: IN PKSERVICE_ROUTINE Isr,
769: IN PVOID ServiceContext,
770: IN KINTERRUPT_MODE InterruptMode,
771: IN BOOLEAN ShareVector,
772: OUT PKINTERRUPT *Interrupt
773: )
774: /*++
775:
776: Routine Description :
777:
778: Connect to an interrupt. From this point on our interrupt service
779: routine can receive interrupts
780:
781: We assume that floating point arithmetic will not be used in the
782: service routine.
783:
784: Arguments :
785:
786: InterruptNumber - the interrupt number we're using
787: BusType - Our bus type
788: BusNumber - the number of our buse (of type BusType)
789: Isr - the interrupt service routine
790: ServiceContext - a value passed to the interrupt service routine
791: InterruptMode - whether it's latched or level sensitive
792: ShareVector - whether the interrupt can be shared
793: Interrupt - Returns the pointer to the interrupt object
794:
795: Return Value :
796:
797: An NTSTATUS return value - STATUS_SUCCESS if OK.
798:
799: --*/
800: {
801: KAFFINITY Affinity;
802: KIRQL InterruptRequestLevel;
803: ULONG InterruptVector;
804: NTSTATUS Status;
805:
806: //
807: // Call HalGetInterruptVector to get the interrupt vector,
808: // processor affinity and request level to pass to IoConnectInterrupt
809: //
810:
811: InterruptVector = HalGetInterruptVector(Isa,
812: BusNumber,
813: InterruptNumber,
814: InterruptNumber,
815: &InterruptRequestLevel,
816: &Affinity);
817:
818:
819: Status = IoConnectInterrupt(
820: Interrupt,
821: Isr,
822: ServiceContext,
823: (PKSPIN_LOCK)NULL,
824: InterruptVector,
825: InterruptRequestLevel,
826: InterruptRequestLevel,
827: InterruptMode,
828: ShareVector,
829: Affinity,
830: FALSE // No floating point save
831: );
832:
833: return Status == STATUS_INVALID_PARAMETER ?
834: STATUS_DEVICE_CONFIGURATION_ERROR : Status;
835: }
836:
837:
838:
839: NTSTATUS
840: SoundSetErrorCode(
841: IN PWSTR RegistryPath,
842: IN ULONG Value
843: )
844: /*++
845:
846: Routine Description :
847:
848: Write the given DWORD into the registry using the path
849: with a value name of SOUND_REG_CONFIGERROR
850:
851: Arguments :
852:
853: RegistryPath- path to registry key
854:
855: Value - value to store
856:
857: Return Value :
858:
859: NTSTATUS code
860:
861: --*/
862: {
863: return SoundWriteRegistryDWORD(RegistryPath, SOUND_REG_CONFIGERROR, Value);
864: }
865:
866:
867: NTSTATUS
868: SoundWriteRegistryDWORD(
869: IN PWSTR RegistryPath,
870: IN PWSTR ValueName,
871: IN ULONG Value
872: )
873: /*++
874:
875: Routine Description :
876:
877: Write the given DWORD into the registry using the path and
878: value name supplied by calling RtlWriteRegistryValue
879:
880: Arguments :
881:
882: RegistryPath- path to registry key
883:
884: ValueName - name of value to write
885:
886: Value - value to store
887:
888: Return Value :
889:
890: NTSTATUS code
891:
892: --*/
893: {
894: NTSTATUS Status;
895:
896: Status = RtlWriteRegistryValue(
897: RTL_REGISTRY_ABSOLUTE,
898: RegistryPath,
899: ValueName,
900: REG_DWORD,
901: &Value,
902: sizeof(Value));
903:
904: if (!NT_SUCCESS(Status)) {
905: dprintf1(("Writing parameter %ls to registry failed status %8X",
906: ValueName, Status));
907: }
908:
909: return Status;
910: }
911:
912:
913: VOID
914: SoundDelay(
915: IN ULONG Milliseconds
916: )
917: /*++
918:
919: Routine Description :
920:
921: Stall the current thread for the given number of milliseconds AT LEAST
922:
923: Arguments :
924:
925: Milliseconds - number of milliseconds to delay
926:
927: Return Value :
928:
929: None
930:
931: --*/
932: {
933: LARGE_INTEGER Delay;
934:
935: //
936: // Can't call SoundDelay() from high irql
937: //
938:
939: if (KeGetCurrentIrql() >= DISPATCH_LEVEL) {
940: return;
941: }
942:
943: //
944: // First a tiny delay to synch us up with the timer otherwise we
945: // may wait up to 15ms less time than we expected!
946: //
947:
948: Delay = RtlConvertLongToLargeInteger(-1);
949:
950: KeDelayExecutionThread(KernelMode,
951: FALSE, // Not alertable
952: &Delay);
953:
954: Delay = RtlConvertLongToLargeInteger((-(LONG)Milliseconds) * 10000);
955:
956: KeDelayExecutionThread(KernelMode,
957: FALSE, // Not alertable
958: &Delay);
959: }
960:
961:
962: LARGE_INTEGER
963: SoundGetTime(
964: VOID
965: )
966: /*++
967:
968: Routine Description:
969:
970: Get an accurate estimate of the current time by calling
971: KeQueryPerformanceCounter and converting the result to 100ns units
972:
973: Arguments:
974:
975: ErrorText - text of message
976:
977: Return Value:
978:
979: --*/
980: {
981: static LARGE_INTEGER StartTime100ns, StartTimeTicks, TicksPerSecond;
982: static BOOLEAN Initialized;
983: static ULONG Multiplier;
984: ULONG Remainder;
985:
986: if (!Initialized) {
987:
988: Initialized = TRUE;
989:
990: KeQuerySystemTime(&StartTime100ns);
991: StartTimeTicks = KeQueryPerformanceCounter(&TicksPerSecond);
992:
993: Multiplier = 10000000;
994:
995: while (TicksPerSecond.HighPart != 0) {
996: Multiplier = Multiplier / 10;
997: TicksPerSecond =
998: RtlExtendedLargeIntegerDivide(TicksPerSecond, 10, &Remainder);
999: }
1000: }
1001:
1002: //
1003: // Convert ticks to 100ns units (and hope we don't overflow!)
1004: //
1005:
1006: return RtlLargeIntegerAdd(
1007: RtlExtendedLargeIntegerDivide(
1008: RtlExtendedIntegerMultiply(
1009: RtlLargeIntegerSubtract(
1010: KeQueryPerformanceCounter(NULL),
1011: StartTimeTicks
1012: ),
1013: Multiplier
1014: ),
1015: TicksPerSecond.LowPart,
1016: &Remainder
1017: ),
1018: StartTime100ns
1019: );
1020: }
1021:
1022:
1023:
1024: VOID
1025: SoundFreeQ(
1026: PLIST_ENTRY ListHead,
1027: NTSTATUS IoStatus
1028: )
1029: /*++
1030:
1031: Routine Description:
1032:
1033: Free a list of Irps - setting the specified status and completing
1034: them. The list will be empty on exit.
1035:
1036: Arguments:
1037:
1038: pListNode - the list to free
1039: IoStatus - the status to set in each Irp.
1040:
1041: Return Value:
1042:
1043: None.
1044:
1045: --*/
1046: {
1047: //
1048: // Remove all the queue entries, completing all
1049: // the Irps represented by the entries
1050: //
1051:
1052: for (;;) {
1053: PIRP pIrp;
1054:
1055: //
1056: // The queue may be cancellable so use our routine to get the Irp
1057: //
1058:
1059: pIrp = SoundRemoveFromCancellableQ(ListHead);
1060:
1061: if (pIrp == NULL) {
1062: break;
1063: }
1064:
1065: pIrp->IoStatus.Status = IoStatus;
1066:
1067: //
1068: // Bump priority here because the application may still be trying
1069: // to be real-time
1070: //
1071: IoCompleteRequest(pIrp, IO_SOUND_INCREMENT);
1072: }
1073: }
1074:
1075:
1076: VOID
1077: SoundRemoveAndComplete(
1078: PDEVICE_OBJECT pDO,
1079: PIRP Irp
1080: )
1081: /*++
1082:
1083: Routine Description:
1084:
1085: Removes the Irp from any queue it's on
1086: Completes it as cancelled.
1087:
1088: Arguments:
1089:
1090: Irp - the Irp
1091: Cancellable - If it is to be made cancellable
1092:
1093: Return Value:
1094:
1095: None.
1096:
1097: Notes:
1098:
1099: This routine is called with the cancel spin lock held
1100:
1101: --*/
1102: {
1103: dprintf2(("Cancelling Irp from cancel routine"));
1104:
1105: //
1106: // Remove the Irp from the queue
1107: //
1108:
1109: RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
1110:
1111: //
1112: // Release the cancel spin lock
1113: //
1114:
1115: IoReleaseCancelSpinLock(Irp->CancelIrql);
1116:
1117: //
1118: // Set status and complete
1119: //
1120:
1121: Irp->IoStatus.Status = STATUS_CANCELLED;
1122:
1123: IoCompleteRequest(Irp, IO_NO_INCREMENT);
1124: }
1125:
1126:
1127:
1128: VOID
1129: SoundAddIrpToCancellableQ(
1130: PLIST_ENTRY QueueHead,
1131: PIRP Irp,
1132: BOOLEAN Head
1133: )
1134: /*++
1135:
1136: Routine Description:
1137:
1138:
1139: Add the Irp to the queue and set the cancel routine under the
1140: protection of the cancel spin lock.
1141:
1142: Arguments:
1143:
1144: QueueHead - the queue to add it to
1145: Irp - the Irp
1146: Head - if TRUE insert at the head of the queue
1147:
1148: Return Value:
1149:
1150: None.
1151:
1152: --*/
1153: {
1154: KIRQL OldIrql;
1155:
1156: //
1157: // Get the cancel spin lock so we can mess with the cancel stuff
1158: //
1159:
1160: IoAcquireCancelSpinLock(&OldIrql);
1161:
1162: //
1163: // Well, it may ALREADY be cancelled!
1164: //
1165:
1166: if (Irp->Cancel) {
1167:
1168: dprintf2(("Irp already cancelled"));
1169:
1170: //
1171: // Release the cancel spin lock
1172: //
1173:
1174: IoReleaseCancelSpinLock(OldIrql);
1175:
1176: //
1177: // Set status and complete
1178: //
1179:
1180: Irp->IoStatus.Status = STATUS_CANCELLED;
1181:
1182: IoCompleteRequest(Irp, IO_NO_INCREMENT);
1183: return;
1184: }
1185:
1186: //
1187: // Set the cancel routine
1188: //
1189:
1190: IoSetCancelRoutine(Irp, SoundRemoveAndComplete);
1191:
1192: //
1193: // Insert it in the queue
1194: //
1195:
1196: if (Head) {
1197: InsertHeadList(QueueHead, &Irp->Tail.Overlay.ListEntry);
1198: } else {
1199: InsertTailList(QueueHead, &Irp->Tail.Overlay.ListEntry);
1200: }
1201:
1202: //
1203: // Free the spin lock
1204: //
1205:
1206: IoReleaseCancelSpinLock(OldIrql);
1207: }
1208:
1209:
1210: PIRP
1211: SoundRemoveFromCancellableQ(
1212: PLIST_ENTRY QueueHead
1213: )
1214: /*++
1215:
1216: Routine Description:
1217:
1218:
1219: Remove the Irp to the queue and remove the cancel routine under the
1220: protection of the cancel spin lock.
1221:
1222: Arguments:
1223:
1224: QueueHead - the queue to remove it from
1225:
1226: Return Value:
1227:
1228: The Irp at the head of the queue or NULL if the queue is empty.
1229:
1230: --*/
1231: {
1232: KIRQL OldIrql;
1233: PIRP Irp;
1234: LIST_ENTRY ListNode;
1235:
1236: //
1237: // Get the cancel spin lock so we can mess with the cancel stuff
1238: //
1239:
1240: IoAcquireCancelSpinLock(&OldIrql);
1241:
1242:
1243: if (IsListEmpty(QueueHead)) {
1244: Irp = NULL;
1245: } else {
1246:
1247: PLIST_ENTRY ListNode;
1248: ListNode = RemoveHeadList(QueueHead);
1249: Irp = CONTAINING_RECORD(ListNode, IRP, Tail.Overlay.ListEntry);
1250:
1251: //
1252: // Remove the cancel routine
1253: //
1254:
1255: IoSetCancelRoutine(Irp, NULL);
1256: }
1257:
1258: //
1259: // Free the spin lock
1260: //
1261:
1262: IoReleaseCancelSpinLock(OldIrql);
1263:
1264: //
1265: // Return IRP (if any)
1266: //
1267:
1268: return Irp;
1269: }
1270:
1271:
1272:
1273: NTSTATUS
1274: SoundSaveRegistryPath(
1275: IN PUNICODE_STRING RegistryPathName,
1276: OUT PWSTR *SavedString
1277: )
1278: /*++
1279:
1280: Routine Description:
1281:
1282: Save the driver's registry path, appending the 'Parameters' key.
1283:
1284: NOTE this registry path must only be accessed BELOW dispatch level
1285: as the save area is allocated from paged pool.
1286:
1287: The caller must free the unicode string buffer if the driver unloads.
1288:
1289: Arguments:
1290:
1291: RegistryPathName - Our driver's registry entry
1292: SavedString - Saved version of RegistryPathName with the 'Parameters'
1293: subkey string appended
1294:
1295: Return Value:
1296:
1297: NTSTATUS code
1298:
1299: --*/
1300: {
1301: int Length;
1302:
1303: ASSERT(*SavedString == NULL);
1304:
1305: Length =
1306: RegistryPathName->Length + sizeof(PARMS_SUBKEY) +
1307: sizeof(UNICODE_NULL); // Include backslash
1308:
1309:
1310: *SavedString =
1311: ExAllocatePool(PagedPool, Length); // Only access on caller thread
1312:
1313: if (*SavedString == NULL) {
1314: return STATUS_INSUFFICIENT_RESOURCES;
1315: }
1316:
1317: //
1318: // Copy the character data
1319: //
1320:
1321: RtlCopyMemory(*SavedString, RegistryPathName->Buffer,
1322: RegistryPathName->Length);
1323:
1324: (*SavedString)[RegistryPathName->Length / sizeof(WCHAR)] = L'\\';
1325: (*SavedString)[RegistryPathName->Length / sizeof(WCHAR) + 1] = UNICODE_NULL;
1326:
1327: //
1328: // Append the parameters suffix prepended by a backslash
1329: //
1330:
1331: wcscat(*SavedString, PARMS_SUBKEY);
1332:
1333: return STATUS_SUCCESS;
1334: }
1335:
1336:
1337: VOID
1338: SoundFlushRegistryKey(
1339: IN PWSTR RegistryPathName
1340: )
1341: /*++
1342:
1343: Routine Description:
1344:
1345: Flush a key - usually the driver's parameters key -
1346: used mainly to save volume settings.
1347:
1348: Arguments:
1349:
1350: RegistryPathName - Our driver's parameters registry entry
1351:
1352: Return Value:
1353:
1354: None
1355:
1356: --*/
1357: {
1358:
1359: HANDLE KeyHandle;
1360: OBJECT_ATTRIBUTES ObjectAttributes;
1361: UNICODE_STRING RegistryPathString;
1362:
1363: RtlInitUnicodeString(&RegistryPathString, RegistryPathName);
1364:
1365: InitializeObjectAttributes(&ObjectAttributes,
1366: &RegistryPathString,
1367: OBJ_CASE_INSENSITIVE,
1368: NULL,
1369: (PSECURITY_DESCRIPTOR)NULL);
1370:
1371: //
1372: // Just open the key and flush it. Not much we can do if this
1373: // fails.
1374: //
1375:
1376: if (NT_SUCCESS(ZwOpenKey(&KeyHandle,
1377: KEY_WRITE,
1378: &ObjectAttributes))) {
1379: ZwFlushKey(KeyHandle);
1380: ZwClose(KeyHandle);
1381: } else {
1382: dprintf1(("Could not open device's key for flushing"));
1383: }
1384: }
1385:
1386: #if 0
1387:
1388: VOID
1389: SoundRaiseHardError(
1390: PWSTR ErrorText
1391: )
1392: /*++
1393:
1394: Routine Description:
1395:
1396: Cause a pop-up - note this doesn't seem to work!
1397:
1398: Arguments:
1399:
1400: ErrorText - text of message
1401:
1402: Return Value:
1403:
1404: None
1405:
1406: --*/
1407: {
1408: UNICODE_STRING String;
1409: RtlInitUnicodeString(&String, ErrorText);
1410: IoRaiseInformationalHardError(STATUS_SUCCESS,
1411: &String,
1412: NULL);
1413: }
1414: #endif
1415:
1416:
1417: #if DBG
1418:
1419: char *DriverName = "Unknown Sound Driver";
1420: ULONG SoundDebugLevel = 1;
1421:
1422: void dDbgOut(char * szFormat, ...)
1423: {
1424: char buf[256];
1425: va_list va;
1426:
1427: va_start(va, szFormat);
1428: vsprintf(buf, szFormat, va);
1429: va_end(va);
1430: DbgPrint("SOUND: %s\n", buf);
1431: }
1432:
1433: #endif // DBG
1434:
1435:
1436:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.