![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to initunlo.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / comm / serial|
Return to initunlo.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / comm / serial |
1.1 root 1: /*++
2:
3: Copyright (c) 1991, 1992, 1993 Microsoft Corporation
4:
5: Module Name:
6:
7: initunlo.c
8:
9: Abstract:
10:
11: This module contains the code that is very specific to initialization
12: and unload operations in the serial driver
13:
14: Author:
15:
16: Anthony V. Ercolano 26-Sep-1991
17:
18: Environment:
19:
20: Kernel mode
21:
22: Revision History :
23:
24: --*/
25:
26: #include <stddef.h>
27: #include "ntddk.h"
28: #include "ntddser.h"
29: #include "serial.h"
30: #include "serialp.h"
31: #include "serlog.h"
32:
33:
34: //
35: // This is the actual definition of SerialDebugLevel.
36: // Note that it is only defined if this is a "debug"
37: // build.
38: //
39: #if DBG
40: extern ULONG SerialDebugLevel = 0;
41: #endif
42:
43: static const PHYSICAL_ADDRESS SerialPhysicalZero = {0};
44:
45: NTSTATUS
46: DriverEntry(
47: IN PDRIVER_OBJECT DriverObject,
48: IN PUNICODE_STRING RegistryPath
49: );
50:
51: NTSTATUS
52: SerialInitializeController(
53: IN PDRIVER_OBJECT DriverObject,
54: IN PCONFIG_DATA ConfigData,
55: IN BOOLEAN MapInterruptStatus,
56: OUT PSERIAL_DEVICE_EXTENSION *DeviceExtension
57: );
58:
59: BOOLEAN
60: SerialDoesPortExist(
61: IN PSERIAL_DEVICE_EXTENSION Extension,
62: PUNICODE_STRING InsertString,
63: IN ULONG ForceFifo
64: );
65:
66: VOID
67: SerialCleanupMultiPort(
68: PSERIAL_DEVICE_EXTENSION *ExtensionList,
69: ULONG NumberOfDevices
70: );
71:
72: VOID
73: SerialGetConfigInfo(
74: IN PDRIVER_OBJECT DriverObject,
75: IN PUNICODE_STRING RegistryPath,
76: ULONG ForceFifoEnableDefault,
77: ULONG RxFifoDefault,
78: OUT PLIST_ENTRY ConfigList
79: );
80:
81: BOOLEAN
82: SerialPutInConfigList(
83: IN PDRIVER_OBJECT DriverObject,
84: IN OUT PLIST_ENTRY ConfigList,
85: IN PCONFIG_DATA New
86: );
87:
88: BOOLEAN
89: SerialResetSynch(
90: IN PVOID Context
91: );
92:
93: PVOID
94: SerialGetMappedAddress(
95: IN INTERFACE_TYPE BusType,
96: IN ULONG BusNumber,
97: PHYSICAL_ADDRESS IoAddress,
98: ULONG NumberOfBytes,
99: ULONG AddressSpace,
100: PBOOLEAN MappedAddress
101: );
102:
103: VOID
104: SerialSetupExternalNaming(
105: IN PSERIAL_DEVICE_EXTENSION Extension
106: );
107:
108: VOID
109: SerialCleanupExternalNaming(
110: IN PSERIAL_DEVICE_EXTENSION Extension
111: );
112:
113: typedef enum _SERIAL_MEM_COMPARES {
114: AddressesAreEqual,
115: AddressesOverlap,
116: AddressesAreDisjoint
117: } SERIAL_MEM_COMPARES,*PSERIAL_MEM_COMPARES;
118:
119: SERIAL_MEM_COMPARES
120: SerialMemCompare(
121: IN PHYSICAL_ADDRESS A,
122: IN ULONG SpanOfA,
123: IN PHYSICAL_ADDRESS B,
124: IN ULONG SpanOfB
125: );
126:
127: VOID
128: SerialPropagateDeleteSharers(
129: IN PSERIAL_DEVICE_EXTENSION Extension,
130: IN OUT PULONG CountSoFar OPTIONAL,
131: IN PKINTERRUPT Interrupt OPTIONAL
132: );
133:
134: VOID
135: SerialInitializeRootInterrupt(
136: IN PDRIVER_OBJECT DriverObject,
137: IN PCONFIG_DATA ConfigData
138: );
139:
140: NTSTATUS
141: SerialInitializeRootMultiPort(
142: IN PDRIVER_OBJECT DriverObject,
143: IN PCONFIG_DATA ConfigData,
144: OUT PSERIAL_DEVICE_EXTENSION *DeviceExtension
145: );
146:
147: NTSTATUS
148: SerialInitializeOneController(
149: IN PDRIVER_OBJECT DriverObject,
150: IN PCONFIG_DATA ConfigData,
151: IN BOOLEAN MapInterruptStatus,
152: OUT PSERIAL_DEVICE_EXTENSION *Extension
153: );
154:
155: VOID
156: SerialLogError(
157: IN PDRIVER_OBJECT DriverObject,
158: IN PDEVICE_OBJECT DeviceObject OPTIONAL,
159: IN PHYSICAL_ADDRESS P1,
160: IN PHYSICAL_ADDRESS P2,
161: IN ULONG SequenceNumber,
162: IN UCHAR MajorFunctionCode,
163: IN UCHAR RetryCount,
164: IN ULONG UniqueErrorValue,
165: IN NTSTATUS FinalStatus,
166: IN NTSTATUS SpecificIOStatus,
167: IN ULONG LengthOfInsert1,
168: IN PWCHAR Insert1,
169: IN ULONG LengthOfInsert2,
170: IN PWCHAR Insert2
171: );
172:
173: NTSTATUS
174: SerialItemCallBack(
175: IN PVOID Context,
176: IN PUNICODE_STRING PathName,
177: IN INTERFACE_TYPE BusType,
178: IN ULONG BusNumber,
179: IN PKEY_VALUE_FULL_INFORMATION *BusInformation,
180: IN CONFIGURATION_TYPE ControllerType,
181: IN ULONG ControllerNumber,
182: IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation,
183: IN CONFIGURATION_TYPE PeripheralType,
184: IN ULONG PeripheralNumber,
185: IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation
186: );
187:
188: NTSTATUS
189: SerialConfigCallBack(
190: IN PVOID Context,
191: IN PUNICODE_STRING PathName,
192: IN INTERFACE_TYPE BusType,
193: IN ULONG BusNumber,
194: IN PKEY_VALUE_FULL_INFORMATION *BusInformation,
195: IN CONFIGURATION_TYPE ControllerType,
196: IN ULONG ControllerNumber,
197: IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation,
198: IN CONFIGURATION_TYPE PeripheralType,
199: IN ULONG PeripheralNumber,
200: IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation
201: );
202:
203: VOID
204: SerialUnReportResourcesDevice(
205: IN PSERIAL_DEVICE_EXTENSION Extension
206: );
207:
208: VOID
209: SerialReportResourcesDevice(
210: IN PSERIAL_DEVICE_EXTENSION Extension,
211: OUT BOOLEAN *ConflictDetected
212: );
213:
214: //
215: // This is exported from the kernel. It is used to point
216: // to the address that the kernel debugger is using.
217: //
218: extern PUCHAR *KdComPortInUse;
219:
220: #ifdef ALLOC_PRAGMA
221: #pragma alloc_text(init,DriverEntry)
222: #pragma alloc_text(init,SerialInitializeRootInterrupt)
223: #pragma alloc_text(init,SerialInitializeRootMultiPort)
224: #pragma alloc_text(init,SerialInitializeOneController)
225: #pragma alloc_text(init,SerialInitializeController)
226: #pragma alloc_text(init,SerialDoesPortExist)
227: #pragma alloc_text(init,SerialItemCallBack)
228: #pragma alloc_text(init,SerialConfigCallBack)
229: #pragma alloc_text(init,SerialGetConfigInfo)
230: #pragma alloc_text(init,SerialPutInConfigList)
231: #pragma alloc_text(init,SerialGetMappedAddress)
232: #pragma alloc_text(init,SerialSetupExternalNaming)
233: #pragma alloc_text(init,SerialMemCompare)
234: #pragma alloc_text(init,SerialReportResourcesDevice)
235: #endif
236:
237:
238: NTSTATUS
239: DriverEntry(
240: IN PDRIVER_OBJECT DriverObject,
241: IN PUNICODE_STRING RegistryPath
242: )
243:
244: /*++
245:
246: Routine Description:
247:
248: The entry point that the system point calls to initialize
249: any driver.
250:
251: This routine will gather the configuration information,
252: report resource usage, attempt to initialize all serial
253: devices, connect to interrupts for ports. If the above
254: goes reasonably well it will fill in the dispatch points,
255: reset the serial devices and then return to the system.
256:
257: Arguments:
258:
259: DriverObject - Just what it says, really of little use
260: to the driver itself, it is something that the IO system
261: cares more about.
262:
263: PathToRegistry - points to the entry for this driver
264: in the current control set of the registry.
265:
266: Return Value:
267:
268: STATUS_SUCCESS if we could initialize a single device,
269: otherwise STATUS_SERIAL_NO_DEVICE_INITED.
270:
271: --*/
272:
273: {
274:
275: //
276: // Holds status information return by various OS and driver
277: // initialization routines.
278: //
279: NTSTATUS status;
280:
281: //
282: // List head for configuration records.
283: //
284: LIST_ENTRY configList;
285:
286: //
287: // Pointer to a device object in the device object chain
288: // hanging off of the driver object.
289: //
290: PDEVICE_OBJECT currentDevice;
291:
292: //
293: // Holds a pointer to a ulong that the Io system maintains
294: // of the count of serial devices.
295: //
296: PULONG countSoFar;
297:
298: //
299: // We use this to query into the registry as to whether we
300: // should break at driver entry.
301: //
302: RTL_QUERY_REGISTRY_TABLE paramTable[5];
303: ULONG zero = 0;
304: ULONG debugLevel = 0;
305: ULONG shouldBreak = 0;
306: ULONG forceFifoEnableDefault;
307: ULONG rxFIFODefault;
308: ULONG notThereDefault = 1234567;
309: PWCHAR path;
310:
311: //
312: // Since the registry path parameter is a "counted" UNICODE string, it
313: // might not be zero terminated. For a very short time allocate memory
314: // to hold the registry path zero terminated so that we can use it to
315: // delve into the registry.
316: //
317: // NOTE NOTE!!!! This is not an architected way of breaking into
318: // a driver. It happens to work for this driver because the author
319: // likes to do things this way.
320: //
321:
322: if (path = ExAllocatePool(
323: PagedPool,
324: RegistryPath->Length+sizeof(WCHAR)
325: )) {
326:
327: RtlZeroMemory(
328: ¶mTable[0],
329: sizeof(paramTable)
330: );
331: RtlZeroMemory(
332: path,
333: RegistryPath->Length+sizeof(WCHAR)
334: );
335: RtlMoveMemory(
336: path,
337: RegistryPath->Buffer,
338: RegistryPath->Length
339: );
340: paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
341: paramTable[0].Name = L"BreakOnEntry";
342: paramTable[0].EntryContext = &shouldBreak;
343: paramTable[0].DefaultType = REG_DWORD;
344: paramTable[0].DefaultData = &zero;
345: paramTable[0].DefaultLength = sizeof(ULONG);
346: paramTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
347: paramTable[1].Name = L"DebugLevel";
348: paramTable[1].EntryContext = &debugLevel;
349: paramTable[1].DefaultType = REG_DWORD;
350: paramTable[1].DefaultData = &zero;
351: paramTable[1].DefaultLength = sizeof(ULONG);
352: paramTable[2].Flags = RTL_QUERY_REGISTRY_DIRECT;
353: paramTable[2].Name = L"ForceFifoEnable";
354: paramTable[2].EntryContext = &forceFifoEnableDefault;
355: paramTable[2].DefaultType = REG_DWORD;
356: paramTable[2].DefaultData = ¬ThereDefault;
357: paramTable[2].DefaultLength = sizeof(ULONG);
358: paramTable[3].Flags = RTL_QUERY_REGISTRY_DIRECT;
359: paramTable[3].Name = L"RxFIFO";
360: paramTable[3].EntryContext = &rxFIFODefault;
361: paramTable[3].DefaultType = REG_DWORD;
362: paramTable[3].DefaultData = ¬ThereDefault;
363: paramTable[3].DefaultLength = sizeof(ULONG);
364:
365: if (!NT_SUCCESS(RtlQueryRegistryValues(
366: RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
367: path,
368: ¶mTable[0],
369: NULL,
370: NULL
371: ))) {
372:
373: shouldBreak = 0;
374: debugLevel = 0;
375:
376: }
377:
378: }
379:
380: #if DBG
381: SerialDebugLevel = debugLevel;
382: #endif
383:
384: if (shouldBreak) {
385:
386: DbgBreakPoint();
387:
388: }
389:
390: //
391: // Check to see if there was a forcefifo or an rxfifo size.
392: // If there isn't then write out values so that they could
393: // be adjusted later.
394: //
395:
396: if (forceFifoEnableDefault == notThereDefault) {
397:
398: forceFifoEnableDefault = 1;
399: RtlWriteRegistryValue(
400: RTL_REGISTRY_ABSOLUTE,
401: path,
402: L"ForceFifoEnable",
403: REG_DWORD,
404: &forceFifoEnableDefault,
405: sizeof(ULONG)
406: );
407:
408: }
409:
410: if (rxFIFODefault == notThereDefault) {
411:
412: rxFIFODefault = 8;
413: RtlWriteRegistryValue(
414: RTL_REGISTRY_ABSOLUTE,
415: path,
416: L"RxFIFO",
417: REG_DWORD,
418: &rxFIFODefault,
419: sizeof(ULONG)
420: );
421:
422: }
423:
424:
425:
426: //
427: // We don't need that path anymore.
428: //
429:
430: if (path) {
431:
432: ExFreePool(path);
433:
434: }
435:
436: //
437: // Just dump out how big the extension is.
438: //
439:
440: SerialDump(
441: SERDIAG1,
442: ("SERIAL: The number of bytes in the extension is: %d\n",
443: sizeof(SERIAL_DEVICE_EXTENSION))
444: );
445:
446:
447: countSoFar = &IoGetConfigurationInformation()->SerialCount;
448:
449: SerialGetConfigInfo(
450: DriverObject,
451: RegistryPath,
452: forceFifoEnableDefault,
453: rxFIFODefault,
454: &configList
455: );
456:
457: //
458: // Initialize each item in the list of configuration records.
459: //
460:
461: while (!IsListEmpty(&configList)) {
462:
463: PCONFIG_DATA currentConfig;
464: PLIST_ENTRY head;
465:
466: head = RemoveHeadList(&configList);
467:
468: currentConfig = CONTAINING_RECORD(
469: head,
470: CONFIG_DATA,
471: ConfigList
472: );
473:
474: SerialInitializeRootInterrupt(
475: DriverObject,
476: currentConfig
477: );
478:
479: }
480:
481: //
482: // We've initialized all of the hardware that this driver
483: // will ever know about. All of the hardware that we know
484: // about is set up to NOT interrupt. We now go through
485: // all of the devices and connect an interrupt object for
486: // all.
487: //
488:
489: currentDevice = DriverObject->DeviceObject;
490:
491: while (currentDevice) {
492:
493: PSERIAL_DEVICE_EXTENSION extension = currentDevice->DeviceExtension;
494:
495: //
496: // This loop will only connect the interrupt for the
497: // "root" controller. When we initialize a root controller
498: // we then propagate that interrupt object to all associate
499: // controllers. If a device doesn't already have an interrupt
500: // and it has an isr then we attempt to connect to the
501: // interrupt. Note that if we fail to connect to an interrupt
502: // we will delete all of the associated devices.
503: //
504:
505: if ((!extension->Interrupt) &&
506: (extension->OurIsr)) {
507:
508: SerialDump(
509: SERDIAG5,
510: ("SERIAL: About to connect to interrupt for port %wZ\n"
511: "------- address of extension is %x\n",
512: &extension->DeviceName,extension)
513: );
514: status = IoConnectInterrupt(
515: &extension->Interrupt,
516: extension->OurIsr,
517: extension->OurIsrContext,
518: NULL,
519: extension->Vector,
520: extension->Irql,
521: extension->Irql,
522: extension->InterruptMode,
523: extension->InterruptShareable,
524: extension->ProcessorAffinity,
525: FALSE
526: );
527:
528: if (!NT_SUCCESS(status)) {
529:
530: //
531: // Hmmm, how'd that happen? Somebody either
532: // didn't report their resources, or they
533: // sneaked in since the last time I looked.
534: //
535: // Oh well, delete this device as well as
536: // any of the devices that were hoping to
537: // share this interrupt.
538: //
539:
540: SerialDump(
541: SERERRORS,
542: ("SERIAL: Couldn't connect to interrupt for %wZ\n",
543: &extension->DeviceName)
544: );
545: SerialLogError(
546: extension->DeviceObject->DriverObject,
547: extension->DeviceObject,
548: extension->OriginalController,
549: SerialPhysicalZero,
550: 0,
551: 0,
552: 0,
553: 1,
554: status,
555: SERIAL_UNREPORTED_IRQL_CONFLICT,
556: extension->SymbolicLinkName.Length+sizeof(WCHAR),
557: extension->SymbolicLinkName.Buffer,
558: 0,
559: NULL
560: );
561: SerialPropagateDeleteSharers(
562: extension,
563: NULL,
564: NULL
565: );
566:
567: //
568: // The above call deleted all the associated
569: // device objects. Who knows what the device
570: // list looks like now! Start over from
571: // the beginning of the device list.
572: //
573:
574: currentDevice = DriverObject->DeviceObject;
575:
576: } else {
577:
578: SerialPropagateDeleteSharers(
579: extension,
580: countSoFar,
581: extension->Interrupt
582: );
583:
584: currentDevice = DriverObject->DeviceObject;
585:
586: }
587:
588: } else {
589:
590: //
591: // We've already done this device. We can go on
592: // to the next device.
593: //
594:
595: currentDevice = currentDevice->NextDevice;
596:
597: }
598:
599: }
600:
601: //
602: // Well if we connected to any interrupts then we should
603: // have some device objects. Go through all of the devices
604: // and reset each device.
605: //
606:
607: currentDevice = DriverObject->DeviceObject;
608:
609: while (currentDevice) {
610:
611: PDEVICE_OBJECT nextDevice = currentDevice->NextDevice;
612: PSERIAL_DEVICE_EXTENSION extension = currentDevice->DeviceExtension;
613:
614: //
615: // While the device isn't open, disable all interrupts.
616: //
617:
618: DISABLE_ALL_INTERRUPTS(extension->Controller);
619:
620: if (extension->Jensen) {
621:
622: WRITE_MODEM_CONTROL(
623: extension->Controller,
624: (UCHAR)SERIAL_MCR_OUT2
625: );
626:
627: } else {
628:
629: WRITE_MODEM_CONTROL(
630: extension->Controller,
631: (UCHAR)0
632: );
633:
634: }
635:
636: //
637: // This should set up everything as it should be when
638: // a device is to be opened. We do need to lower the
639: // modem lines, and disable the stupid fifo so that it
640: // will show up if the user boots to dos.
641: //
642:
643: KeSynchronizeExecution(
644: extension->Interrupt,
645: SerialReset,
646: currentDevice->DeviceExtension
647: );
648: KeSynchronizeExecution( //Disables the fifo.
649: extension->Interrupt,
650: SerialMarkClose,
651: currentDevice->DeviceExtension
652: );
653: KeSynchronizeExecution(
654: extension->Interrupt,
655: SerialClrRTS,
656: currentDevice->DeviceExtension
657: );
658: KeSynchronizeExecution(
659: extension->Interrupt,
660: SerialClrDTR,
661: currentDevice->DeviceExtension
662: );
663:
664:
665: currentDevice = nextDevice;
666:
667: }
668:
669: if (DriverObject->DeviceObject) {
670:
671: status = STATUS_SUCCESS;
672:
673: //
674: // Initialize the Driver Object with driver's entry points
675: //
676:
677: DriverObject->DriverUnload = SerialUnload;
678: DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = SerialFlush;
679: DriverObject->MajorFunction[IRP_MJ_WRITE] = SerialWrite;
680: DriverObject->MajorFunction[IRP_MJ_READ] = SerialRead;
681: DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = SerialIoControl;
682: DriverObject->MajorFunction[IRP_MJ_CREATE] = SerialCreateOpen;
683: DriverObject->MajorFunction[IRP_MJ_CLOSE] = SerialClose;
684: DriverObject->MajorFunction[IRP_MJ_CLEANUP] = SerialCleanup;
685: DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] =
686: SerialQueryInformationFile;
687: DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] =
688: SerialSetInformationFile;
689:
690: } else {
691:
692: status = STATUS_SERIAL_NO_DEVICE_INITED;
693:
694: }
695:
696: return status;
697: }
698:
699: VOID
700: SerialPropagateDeleteSharers(
701: IN PSERIAL_DEVICE_EXTENSION Extension,
702: IN OUT PULONG CountSoFar OPTIONAL,
703: IN PKINTERRUPT Interrupt OPTIONAL
704: )
705:
706: /*++
707:
708: Routine Description:
709:
710: This routine will either propagate the interrupt object
711: to all extensions sharing the same interrupt, or it will
712: delete all devices sharing the same interrupt.
713:
714: Arguments:
715:
716: Extension - "Listhead" of all devices sharing the same
717: interrupt.
718:
719: CountSoFar - If interrupt is present and this is present,
720: we will increment the longword pointed to
721: by this pointer for each device extension
722: we stick the interrupt into.
723:
724: If interrupt is *not* present and this
725: pointer *is* present, we will decrement the
726: longword pointed to by this value for
727: each device we delete.
728:
729: If this isn't present, well, then, I guess
730: we won't do anything with it.
731:
732: Interrupt - If this is present, we propagate it to
733: all devices on that want to share the interrupt.
734:
735:
736: Return Value:
737:
738: None.
739:
740: --*/
741:
742: {
743:
744: ASSERT(Extension->OurIsr);
745:
746: SerialDump(
747: SERDIAG3,
748: ("SERIAL: In SerialPropagateDeleteSharers\n"
749: "------- Extension: %x CountSoFar: %d Interrupt: %x\n",
750: Extension,*CountSoFar,Interrupt)
751: );
752:
753: if (Interrupt) {
754:
755: PLIST_ENTRY currentEntry;
756: PLIST_ENTRY firstEntry;
757:
758: SerialDump(
759: SERDIAG5,
760: ("SERIAL: In the report propagate path\n")
761: );
762:
763: //
764: // Were supposed to place the interrupt object
765: // in every associated device object.
766: //
767:
768: currentEntry = &Extension->CommonInterruptObject;
769: firstEntry = currentEntry;
770:
771: do {
772:
773: PSERIAL_DEVICE_EXTENSION currentExtension;
774:
775: currentExtension = CONTAINING_RECORD(
776: currentEntry,
777: SERIAL_DEVICE_EXTENSION,
778: CommonInterruptObject
779: );
780:
781: currentExtension->Interrupt = Interrupt;
782:
783:
784: if (ARGUMENT_PRESENT(CountSoFar)) {
785:
786: *CountSoFar += 1;
787:
788: }
789:
790: currentEntry = currentExtension->CommonInterruptObject.Flink;
791:
792: } while (currentEntry != firstEntry);
793:
794: } else {
795:
796: LIST_ENTRY listHead;
797:
798: //
799: // We are supposed to delete all of the devices
800: // in the linked list.
801: //
802: // First we make a local list head that doesn't
803: // have the current extension as part of the list.
804: //
805: // The we cleanup and delete the "root" device.
806: //
807: // The we traverse all of the associated device
808: // extensions and null out the interrupt object
809: // (this way subsequent cleanup code won't attempt
810: // to disconnect the interrupt object) then we
811: // cleanup and delete the device.
812: //
813:
814: SerialDump(
815: SERDIAG5,
816: ("SERIAL: In the deletion/unreport path\n")
817: );
818:
819: InitializeListHead(&listHead);
820:
821: if (!IsListEmpty(&Extension->CommonInterruptObject)) {
822:
823: PLIST_ENTRY old = Extension->CommonInterruptObject.Flink;
824:
825: RemoveEntryList(&Extension->CommonInterruptObject);
826: InsertTailList(
827: old,
828: &listHead
829: );
830:
831: }
832:
833: if (ARGUMENT_PRESENT(CountSoFar)) {
834:
835: //
836: // An implication of decrementing the
837: // count is that the device has reported
838: // it's resources already. Now unreport
839: // them.
840: //
841:
842: *CountSoFar -= 1;
843: SerialUnReportResourcesDevice(Extension);
844:
845: }
846:
847: SerialCleanupDevice(Extension);
848: IoDeleteDevice(Extension->DeviceObject);
849:
850: while (!IsListEmpty(&listHead)) {
851:
852: PLIST_ENTRY head;
853: PSERIAL_DEVICE_EXTENSION currentExtension;
854:
855: head = RemoveHeadList(&listHead);
856:
857: currentExtension = CONTAINING_RECORD(
858: head,
859: SERIAL_DEVICE_EXTENSION,
860: CommonInterruptObject
861: );
862:
863: currentExtension->Interrupt = NULL;
864:
865: if (ARGUMENT_PRESENT(CountSoFar)) {
866:
867: *CountSoFar -= 1;
868: SerialUnReportResourcesDevice(currentExtension);
869:
870: }
871:
872: SerialCleanupDevice(currentExtension);
873: IoDeleteDevice(currentExtension->DeviceObject);
874:
875: }
876:
877: }
878:
879: }
880:
881: VOID
882: SerialInitializeRootInterrupt(
883: IN PDRIVER_OBJECT DriverObject,
884: IN PCONFIG_DATA ConfigData
885: )
886:
887: /*++
888:
889: Routine Description:
890:
891: This routine attempts to build a list suitable for dispatching
892: to multiple extensions for devices that want to share an interrupt.
893: Note that this includes the degenerate case of a single port who
894: wont be sharing.
895:
896: Arguments:
897:
898: DriverObject - Simply passed on to the controller initialization.
899:
900: ConfigData - Root of a "tree" of configuration records.
901:
902: Return Value:
903:
904: None.
905:
906: --*/
907:
908: {
909:
910: PSERIAL_DEVICE_EXTENSION rootExtension = NULL;
911: PCONFIG_DATA originalConfig = ConfigData;
912: PCONFIG_DATA currentConfig = ConfigData;
913: LIST_ENTRY listHead;
914:
915: SerialDump(
916: SERDIAG3,
917: ("SERIAL: In SerialInitializeRootInterrupt\n")
918: );
919:
920: //
921: // This makes the listhead imbedded in the root config
922: // record a local list head. That list no longer has the
923: // original config record as part of the list.
924: //
925:
926: InitializeListHead(&listHead);
927:
928: if (!IsListEmpty(&ConfigData->SameInterrupt)) {
929:
930: PLIST_ENTRY old = ConfigData->SameInterrupt.Flink;
931:
932: RemoveEntryList(&ConfigData->SameInterrupt);
933: InsertTailList(
934: old,
935: &listHead
936: );
937:
938: }
939:
940: //
941: // If we are on a MicroChannel bus then all the configs can simply
942: // share the interrupt.
943: //
944:
945: if (ConfigData->InterfaceType == MicroChannel) {
946:
947: //
948: // We know that all of the configs on this "chain"
949: // are using the MicroChannel.
950: //
951:
952: while (currentConfig) {
953:
954: if (!IsListEmpty(¤tConfig->SameInterruptStatus)) {
955:
956: //
957: // This is a multiport card, call its intialization.
958: //
959:
960: SerialDump(
961: SERDIAG5,
962: ("SERIAL: Attempting to make %wZ with controller at %x\n"
963: "------- and status at %x a same interrupt root of multiports\n"
964: "------- On a MicroChannel.\n",
965: ¤tConfig->NtNameForPort,currentConfig->Controller.LowPart,
966: currentConfig->InterruptStatus.LowPart)
967: );
968: SerialInitializeRootMultiPort(
969: DriverObject,
970: currentConfig,
971: &rootExtension
972: );
973:
974: } else {
975:
976: SerialDump(
977: SERDIAG5,
978: ("SERIAL: Attempting to make %wZ with controller at %x\n"
979: "------- A same interrupt single controller On a MicroChannel.\n",
980: ¤tConfig->NtNameForPort,currentConfig->Controller.LowPart)
981: );
982: SerialInitializeOneController(
983: DriverObject,
984: currentConfig,
985: FALSE,
986: &rootExtension
987: );
988:
989: }
990: SerialDump(
991: SERDIAG5,
992: ("SERIAL: It came back with a same interrupt rootExtension of %x\n",
993: rootExtension)
994: );
995:
996: if (!IsListEmpty(&listHead)) {
997:
998: PLIST_ENTRY head;
999:
1000: head = RemoveHeadList(&listHead);
1001:
1002: currentConfig = CONTAINING_RECORD(
1003: head,
1004: CONFIG_DATA,
1005: SameInterrupt
1006: );
1007:
1008: } else {
1009:
1010: currentConfig = NULL;
1011: rootExtension = NULL;
1012:
1013: }
1014:
1015: }
1016:
1017:
1018: } else {
1019:
1020: //
1021: // We have to set up to do "shareing" of interrupt resources.
1022: //
1023:
1024: //
1025: // We first keep trying to initialize one of the
1026: // configs on the chain until one succeeds.
1027: //
1028:
1029: while ((!rootExtension) && currentConfig) {
1030:
1031: NTSTATUS status;
1032:
1033: if (!IsListEmpty(¤tConfig->SameInterruptStatus)) {
1034:
1035: //
1036: // This is a multiport card, call its intialization.
1037: //
1038:
1039: SerialDump(
1040: SERDIAG5,
1041: ("SERIAL: Attempting to make %wZ with controller at %x\n"
1042: "------- and status at %x a same interrupt sharer root controller\n",
1043: ¤tConfig->NtNameForPort,currentConfig->Controller.LowPart,
1044: currentConfig->InterruptStatus.LowPart)
1045: );
1046: status = SerialInitializeRootMultiPort(
1047: DriverObject,
1048: currentConfig,
1049: &rootExtension
1050: );
1051:
1052: } else {
1053:
1054: SerialDump(
1055: SERDIAG5,
1056: ("SERIAL: Attempting to make %wZ with controller at %x\n"
1057: "------- A single same interrupt sharer root controller.\n",
1058: ¤tConfig->NtNameForPort,currentConfig->Controller.LowPart)
1059: );
1060: status = SerialInitializeOneController(
1061: DriverObject,
1062: currentConfig,
1063: FALSE,
1064: &rootExtension
1065: );
1066:
1067: }
1068:
1069: SerialDump(
1070: SERDIAG5,
1071: ("SERIAL: It came back with a same interrupt rootExtension of %x\n",
1072: rootExtension)
1073: );
1074:
1075: if (!NT_SUCCESS(status)) {
1076:
1077: //
1078: // Well that one didn't work. Try the next one.
1079: //
1080:
1081: if (!IsListEmpty(&listHead)) {
1082:
1083: PLIST_ENTRY head;
1084:
1085: head = RemoveHeadList(&listHead);
1086:
1087: currentConfig = CONTAINING_RECORD(
1088: head,
1089: CONFIG_DATA,
1090: SameInterrupt
1091: );
1092:
1093: } else {
1094:
1095: currentConfig = NULL;
1096: rootExtension = NULL;
1097:
1098: }
1099:
1100: } else {
1101:
1102: //
1103: // We save off the isr to use and the context to the
1104: // isr into the following fields. Unless the
1105: // device is actually sharing the interrupt with
1106: // another "card" this field will not be
1107: // needed.
1108: //
1109:
1110: rootExtension->TopLevelOurIsr = rootExtension->OurIsr;
1111: rootExtension->TopLevelOurIsrContext = rootExtension->OurIsrContext;
1112:
1113: }
1114:
1115:
1116: }
1117:
1118: if (rootExtension) {
1119:
1120: //
1121: // We have a root extension! Now try to
1122: // all intialize all the other configs on this
1123: // interrupt.
1124: //
1125:
1126: ULONG numberOfSharers = 1;
1127:
1128: while (!IsListEmpty(&listHead)) {
1129:
1130: NTSTATUS status;
1131: PLIST_ENTRY head;
1132: PSERIAL_DEVICE_EXTENSION newExtension;
1133:
1134: head = RemoveHeadList(&listHead);
1135:
1136: currentConfig = CONTAINING_RECORD(
1137: head,
1138: CONFIG_DATA,
1139: SameInterrupt
1140: );
1141:
1142: if (!IsListEmpty(¤tConfig->SameInterruptStatus)) {
1143:
1144: //
1145: // This is a multiport card, call its intialization.
1146: //
1147:
1148: SerialDump(
1149: SERDIAG5,
1150: ("SERIAL: Attempting to make %wZ with controller at %x\n"
1151: "------- and status at %x a same interrupt sharer multiports\n",
1152: ¤tConfig->NtNameForPort,currentConfig->Controller.LowPart,
1153: currentConfig->InterruptStatus.LowPart)
1154: );
1155: status = SerialInitializeRootMultiPort(
1156: DriverObject,
1157: currentConfig,
1158: &newExtension
1159: );
1160:
1161: } else {
1162:
1163: SerialDump(
1164: SERDIAG5,
1165: ("SERIAL: Attempting to make %wZ with controller at %x\n"
1166: "------- A single same interrupt sharer controller.\n",
1167: ¤tConfig->NtNameForPort,currentConfig->Controller.LowPart)
1168: );
1169: status = SerialInitializeOneController(
1170: DriverObject,
1171: currentConfig,
1172: FALSE,
1173: &newExtension
1174: );
1175:
1176: }
1177:
1178: SerialDump(
1179: SERDIAG5,
1180: ("SERIAL: It came back with a same interrupt newExtension of %x\n",
1181: rootExtension)
1182: );
1183:
1184:
1185: if (NT_SUCCESS(status)) {
1186:
1187: PLIST_ENTRY rootTail;
1188: PLIST_ENTRY newTail;
1189:
1190: //
1191: // Propagate the isr routine and context
1192: // up to the sharing list.
1193: //
1194:
1195: newExtension->TopLevelOurIsr = newExtension->OurIsr;
1196: newExtension->TopLevelOurIsrContext = newExtension->OurIsrContext;
1197: newExtension->OurIsr = NULL;
1198: newExtension->OurIsrContext = NULL;
1199:
1200: //
1201: // Append this top level extension onto the list of
1202: // other top level interrupt sharers.
1203: //
1204:
1205: InsertTailList(
1206: &rootExtension->TopLevelSharers,
1207: &newExtension->TopLevelSharers
1208: );
1209:
1210: //
1211: // Link together the lists of extensions that will
1212: // be using the same interrupt object (not necessarily)
1213: // the same "interrupt service routine" (actually dispatchers).
1214: //
1215:
1216: rootTail =
1217: rootExtension->CommonInterruptObject.Blink;
1218: newTail =
1219: newExtension->CommonInterruptObject.Blink;
1220:
1221: rootExtension->CommonInterruptObject.Blink =
1222: newTail;
1223: newExtension->CommonInterruptObject.Blink =
1224: rootTail;
1225: rootTail->Flink =
1226: &newExtension->CommonInterruptObject;
1227: newTail->Flink =
1228: &rootExtension->CommonInterruptObject;
1229:
1230: numberOfSharers++;
1231:
1232: }
1233:
1234: }
1235:
1236: //
1237: // All done initializing the other sharers.
1238: //
1239: // If none of the others actually initialized
1240: // the we simply degenerate into the interrupt
1241: // handling for the root extension. (This requires
1242: // no additional work.)
1243: //
1244:
1245: if (numberOfSharers > 1) {
1246:
1247: //
1248: // Replace the Isr and context for the root
1249: // with the pointer to the "sharer" dispatcher
1250: // and a pointer to the list of share entries
1251: // as context.
1252: //
1253:
1254: SerialDump(
1255: SERDIAG5,
1256: ("SERIAL: We do have more than one sharer for the interrupt.\n"
1257: "------- The controlling extension should be %x\n",
1258: rootExtension)
1259: );
1260: rootExtension->OurIsr = SerialSharerIsr;
1261: rootExtension->OurIsrContext = &rootExtension->TopLevelSharers;
1262:
1263: }
1264:
1265: }
1266:
1267: }
1268:
1269: }
1270:
1271: NTSTATUS
1272: SerialInitializeRootMultiPort(
1273: IN PDRIVER_OBJECT DriverObject,
1274: IN PCONFIG_DATA ConfigData,
1275: OUT PSERIAL_DEVICE_EXTENSION *DeviceExtension
1276: )
1277:
1278: /*++
1279:
1280: Routine Description:
1281:
1282: This routine attempts to initialize all the ports on a
1283: multiport board and to build a structure so that an
1284: isr can dispatch to the particular ports device extension.
1285:
1286: Arguments:
1287:
1288: DriverObject - Simply passed on to the controller initialization
1289: routine.
1290:
1291: ConfigData - A linked list of configuration information for all
1292: the ports on a multiport card.
1293:
1294: DeviceExtension - Will point to the first successfully initialized
1295: port on the multiport card.
1296:
1297: Return Value:
1298:
1299: None.
1300:
1301: --*/
1302:
1303: {
1304:
1305: PSERIAL_DEVICE_EXTENSION rootExtension = NULL;
1306: PCONFIG_DATA originalConfig = ConfigData;
1307: PCONFIG_DATA currentConfig = ConfigData;
1308: ULONG indexed;
1309: ULONG portIndex;
1310: LIST_ENTRY listHead;
1311: NTSTATUS status;
1312:
1313: SerialDump(
1314: SERDIAG3,
1315: ("SERIAL: In SerialInitializeRootMultiPort\n")
1316: );
1317: *DeviceExtension = NULL;
1318:
1319: //
1320: // This makes the listhead imbedded in the root config
1321: // record a local list head. The old head of the list
1322: // (the current config) will no longer be part of the list.
1323: //
1324:
1325: InitializeListHead(&listHead);
1326:
1327: if (!IsListEmpty(&ConfigData->SameInterruptStatus)) {
1328:
1329: PLIST_ENTRY old = ConfigData->SameInterruptStatus.Flink;
1330:
1331: RemoveEntryList(&ConfigData->SameInterruptStatus);
1332: InsertTailList(
1333: old,
1334: &listHead
1335: );
1336:
1337: }
1338:
1339: //
1340: // The indexed field is valid for all ports on the chain.
1341: //
1342:
1343: indexed = ConfigData->Indexed;
1344: SerialDump(
1345: SERDIAG5,
1346: ("SERIAL: This indexed value for this multiport is: %d\n",indexed)
1347: );
1348:
1349: //
1350: // We first keep trying to initialize one of the
1351: // ports on the chain until one succeeds.
1352: //
1353:
1354: while ((!rootExtension) && currentConfig) {
1355:
1356: portIndex = currentConfig->PortIndex;
1357:
1358: SerialDump(
1359: SERDIAG5,
1360: ("SERIAL: Attempting to make %wZ with controller at %x\n"
1361: "------- and status at %x a root of multiports\n",
1362: ¤tConfig->NtNameForPort,currentConfig->Controller.LowPart,
1363: currentConfig->InterruptStatus.LowPart)
1364: );
1365: status = SerialInitializeOneController(
1366: DriverObject,
1367: currentConfig,
1368: TRUE,
1369: &rootExtension
1370: );
1371: SerialDump(
1372: SERDIAG5,
1373: ("SERIAL: Multiport came back with a same interrupt rootExtension of %x\n",
1374: rootExtension)
1375: );
1376:
1377: if (!NT_SUCCESS(status)) {
1378:
1379: //
1380: // Well that one didn't work. Try the next one.
1381: //
1382:
1383: if (!IsListEmpty(&listHead)) {
1384:
1385: PLIST_ENTRY head;
1386:
1387: head = RemoveHeadList(&listHead);
1388:
1389: currentConfig = CONTAINING_RECORD(
1390: head,
1391: CONFIG_DATA,
1392: SameInterruptStatus
1393: );
1394:
1395: } else {
1396:
1397: currentConfig = NULL;
1398: rootExtension = NULL;
1399:
1400: }
1401:
1402: }
1403:
1404: }
1405:
1406: if (rootExtension) {
1407:
1408: //
1409: // Well we have at least one controller. We build a local
1410: // dispatch structure. If we end up being able to
1411: // intialize another port then we will allocate
1412: // the dispatch structure out of pool. If we can't
1413: // intialize anymore ports then this degenerates into a
1414: // single port case.
1415: //
1416:
1417: ULONG numberOfPorts = 1;
1418: SERIAL_MULTIPORT_DISPATCH dispatch;
1419:
1420: rootExtension->PortOnAMultiportCard = TRUE;
1421:
1422: RtlZeroMemory(
1423: &dispatch,
1424: sizeof(SERIAL_MULTIPORT_DISPATCH)
1425: );
1426:
1427: if (!indexed) {
1428:
1429: dispatch.UsablePortMask = 1 << (portIndex-1);
1430:
1431: }
1432:
1433: dispatch.InterruptStatus = rootExtension->InterruptStatus;
1434:
1435: dispatch.Extensions[portIndex-1] = rootExtension;
1436:
1437: while (!IsListEmpty(&listHead)) {
1438:
1439: PLIST_ENTRY head;
1440: PSERIAL_DEVICE_EXTENSION newExtension;
1441:
1442: head = RemoveHeadList(&listHead);
1443:
1444: currentConfig = CONTAINING_RECORD(
1445: head,
1446: CONFIG_DATA,
1447: SameInterruptStatus
1448: );
1449:
1450: portIndex = currentConfig->PortIndex;
1451:
1452: if (NT_SUCCESS(SerialInitializeOneController(
1453: DriverObject,
1454: currentConfig,
1455: FALSE,
1456: &newExtension
1457: ))) {
1458:
1459: numberOfPorts++;
1460: newExtension->PortOnAMultiportCard = TRUE;
1461:
1462: if (!indexed) {
1463:
1464: dispatch.UsablePortMask |= 1 << (portIndex-1);
1465:
1466: }
1467:
1468: dispatch.Extensions[portIndex-1] = newExtension;
1469:
1470: InsertTailList(
1471: &rootExtension->CommonInterruptObject,
1472: &newExtension->CommonInterruptObject
1473: );
1474:
1475: }
1476:
1477: }
1478:
1479: //
1480: // If the number of ports is still one that means we
1481: // couldn't initialize any more extensions. This then
1482: // degenerates into a single port card. Note that there
1483: // is no work to do in that case, it was set up in
1484: // SerialInitializeSingleController.
1485: //
1486:
1487: if (numberOfPorts > 1) {
1488:
1489: //
1490: // Now allocate the dispatch structure out of pool
1491: // since it certain that we will actually use it.
1492: //
1493:
1494: rootExtension->OurIsrContext = ExAllocatePool(
1495: NonPagedPool,
1496: sizeof(SERIAL_MULTIPORT_DISPATCH)
1497: );
1498:
1499: if (!rootExtension->OurIsrContext) {
1500:
1501: //
1502: // Darn! Couldn't allocate the dispatch structure.
1503: //
1504: // Seems as though the safest thing to do in
1505: // this case is to act as though none of the ports
1506: // initialized. Go through and delete all of the
1507: // devices that were initialized.
1508: //
1509: // This should be fairly safe since the initialize controller
1510: // code completely disables the port from interrupting.
1511: //
1512:
1513: ULONG i;
1514:
1515: SerialDump(
1516: SERERRORS,
1517: ("SERIAL: Couldn't allocate memory for %wZ\n"
1518: "------- multiport dispatch structure"
1519: "------- deleting all associated devices",
1520: &rootExtension->DeviceName)
1521: );
1522:
1523: //
1524: // We couldn't allocate memory for it, hopefully
1525: // the logger can make some headway.
1526: //
1527:
1528: SerialLogError(
1529: rootExtension->DeviceObject->DriverObject,
1530: rootExtension->DeviceObject,
1531: rootExtension->OriginalController,
1532: SerialPhysicalZero,
1533: 0,
1534: 0,
1535: 0,
1536: 2,
1537: STATUS_SUCCESS,
1538: SERIAL_INSUFFICIENT_RESOURCES,
1539: 0,
1540: NULL,
1541: 0,
1542: NULL
1543: );
1544:
1545: for (
1546: i = 0;
1547: numberOfPorts;
1548: i++
1549: ) {
1550:
1551: if (dispatch.Extensions[i]) {
1552:
1553: SerialCleanupDevice(dispatch.Extensions[i]);
1554: IoDeleteDevice(
1555: dispatch.Extensions[i]->DeviceObject
1556: );
1557: numberOfPorts--;
1558:
1559: }
1560:
1561: }
1562:
1563: return STATUS_INSUFFICIENT_RESOURCES;
1564:
1565: } else {
1566:
1567: ULONG i;
1568: PSERIAL_MULTIPORT_DISPATCH allocatedDispatch =
1569: rootExtension->OurIsrContext;
1570:
1571: //
1572: // Go throught the list of extensions and NULL
1573: // their pointers to the isr. The only extension
1574: // that will truely have an isr is the root.
1575: //
1576:
1577: allocatedDispatch->UsablePortMask = dispatch.UsablePortMask;
1578: allocatedDispatch->InterruptStatus = dispatch.InterruptStatus;
1579:
1580: for (
1581: i = 0;
1582: i < SERIAL_MAX_PORTS_NONINDEXED;
1583: i++
1584: ) {
1585:
1586: allocatedDispatch->Extensions[i] = dispatch.Extensions[i];
1587:
1588: if (dispatch.Extensions[i]) {
1589: dispatch.Extensions[i]->OurIsr = NULL;
1590: }
1591:
1592: }
1593:
1594: if (indexed) {
1595:
1596: rootExtension->OurIsr = SerialIndexedMultiportIsr;
1597:
1598: } else {
1599:
1600: rootExtension->OurIsr = SerialBitMappedMultiportIsr;
1601:
1602: }
1603:
1604: }
1605:
1606: }
1607:
1608: *DeviceExtension = rootExtension;
1609: return STATUS_SUCCESS;
1610:
1611: } else {
1612:
1613: return STATUS_UNSUCCESSFUL;
1614:
1615: }
1616:
1617: }
1618:
1619: NTSTATUS
1620: SerialInitializeOneController(
1621: IN PDRIVER_OBJECT DriverObject,
1622: IN PCONFIG_DATA ConfigData,
1623: IN BOOLEAN MapInterruptStatus,
1624: OUT PSERIAL_DEVICE_EXTENSION *Extension
1625: )
1626:
1627: /*++
1628:
1629: Routine Description:
1630:
1631: This routine will call the real port initializatio code.
1632: If all was successful, it will save off in the extension
1633: the isr that should be used as well as a pointer to
1634: the extension itself.
1635:
1636: This is the only routine responsible for deleting the
1637: configuration information subsequent to getting it all
1638: from the registry.
1639:
1640: Arguments:
1641:
1642: DriverObject - Simply passed on to the controller initialization
1643: routine.
1644:
1645: ConfigData - Pointer to a record for a single port.
1646:
1647: MapInterruptStatus - Simply passed on to the controller initialization
1648: routine.
1649:
1650: Extension - Points to the device extension of the successfully
1651: initialized controller.
1652:
1653: Return Value:
1654:
1655: Status returned from the controller initialization routine.
1656:
1657: --*/
1658:
1659: {
1660:
1661: NTSTATUS status;
1662:
1663: status = SerialInitializeController(
1664: DriverObject,
1665: ConfigData,
1666: MapInterruptStatus,
1667: Extension
1668: );
1669:
1670: if (NT_SUCCESS(status)) {
1671:
1672: //
1673: // We successfully initialized the single controller.
1674: // Stick the isr routine and the parameter for it
1675: // back into the extension.
1676: //
1677:
1678: (*Extension)->OurIsr = SerialISR;
1679: (*Extension)->OurIsrContext = *Extension;
1680:
1681: } else {
1682:
1683: *Extension = NULL;
1684:
1685: }
1686:
1687: return status;
1688:
1689: }
1690:
1691: NTSTATUS
1692: SerialInitializeController(
1693: IN PDRIVER_OBJECT DriverObject,
1694: IN PCONFIG_DATA ConfigData,
1695: IN BOOLEAN MapInterruptStatus,
1696: OUT PSERIAL_DEVICE_EXTENSION *DeviceExtension
1697: )
1698:
1699: /*++
1700:
1701: Routine Description:
1702:
1703: Really too many things to mention here. In general, it forms
1704: and sets up names, creates the device, initializes kernel
1705: synchronization structures, allocates the typeahead buffer,
1706: sets up defaults, etc.
1707:
1708: Arguments:
1709:
1710: DriverObject - Just used to create the device object.
1711:
1712: ConfigData - Pointer to a record for a single port.
1713:
1714: NOTE: This routine will deallocate the config data.
1715:
1716: MapInterruptStatus - If true, we will attempt to map the
1717: interrupt status register associated
1718: with this port..
1719:
1720: DeviceExtension - Points to the device extension of the successfully
1721: initialized controller.
1722:
1723: Return Value:
1724:
1725: STATUS_SUCCCESS if everything went ok. A !NT_SUCCESS status
1726: otherwise.
1727:
1728: --*/
1729:
1730: {
1731:
1732: //
1733: // This will hold the string that we need to use to describe
1734: // the name of the device to the IO system.
1735: //
1736: UNICODE_STRING uniNameString;
1737:
1738: //
1739: // Holds the NT Status that is returned from each call to the
1740: // kernel and executive.
1741: //
1742: NTSTATUS status = STATUS_SUCCESS;
1743:
1744: //
1745: // Points to the device object (not the extension) created
1746: // for this device.
1747: //
1748: PDEVICE_OBJECT deviceObject;
1749:
1750: //
1751: // Points to the device extension for the device object
1752: // (see above) created for the device we are initializing.
1753: //
1754: PSERIAL_DEVICE_EXTENSION extension = NULL;
1755:
1756: //
1757: // Indicates that we successfully reported the resources
1758: // used by this device.
1759: //
1760: BOOLEAN reportedResources = FALSE;
1761:
1762: //
1763: // Indicates that a conflict was detected for resources
1764: // used by this device.
1765: //
1766: BOOLEAN conflictDetected = FALSE;
1767:
1768: SerialDump(
1769: SERDIAG1,
1770: ("SERIAL: Initializing for configuration record of %wZ\n",
1771: &ConfigData->NtNameForPort)
1772: );
1773: if ((*KdComPortInUse) ==
1774:
1775: ((PUCHAR)(ConfigData->Controller.LowPart))) {
1776: SerialDump(
1777: SERERRORS,
1778: ("SERIAL: Kernel debugger is using port at address %x\n"
1779: "------ Serial driver will not load port %wZ\n",
1780: *KdComPortInUse,&ConfigData->SymbolicLinkName)
1781: );
1782:
1783: SerialLogError(
1784: DriverObject,
1785: NULL,
1786: ConfigData->Controller,
1787: SerialPhysicalZero,
1788: 0,
1789: 0,
1790: 0,
1791: 3,
1792: STATUS_SUCCESS,
1793: SERIAL_KERNEL_DEBUGGER_ACTIVE,
1794: ConfigData->SymbolicLinkName.Length+sizeof(WCHAR),
1795: ConfigData->SymbolicLinkName.Buffer,
1796: 0,
1797: NULL
1798: );
1799:
1800: ExFreePool(ConfigData->ObjectDirectory.Buffer);
1801: ExFreePool(ConfigData->NtNameForPort.Buffer);
1802: ExFreePool(ConfigData->SymbolicLinkName.Buffer);
1803: ExFreePool(ConfigData);
1804: return STATUS_INSUFFICIENT_RESOURCES;
1805:
1806: }
1807:
1808: //
1809: // Form a name like \Device\Serial0.
1810: //
1811: // First we allocate space for the name.
1812: //
1813:
1814: RtlInitUnicodeString(
1815: &uniNameString,
1816: NULL
1817: );
1818:
1819: uniNameString.MaximumLength = sizeof(L"\\Device\\") +
1820: ConfigData->NtNameForPort.Length+sizeof(WCHAR);
1821: uniNameString.Buffer = ExAllocatePool(
1822: PagedPool,
1823: uniNameString.MaximumLength
1824: );
1825:
1826: //
1827: // The only reason the above could have failed is if
1828: // there wasn't enough system memory to form the UNICODE
1829: // string.
1830: //
1831:
1832: if (!uniNameString.Buffer) {
1833:
1834: SerialDump(
1835: SERERRORS,
1836: ("SERIAL: Could not form Unicode name string for %wZ\n",
1837: &ConfigData->NtNameForPort)
1838: );
1839: SerialLogError(
1840: DriverObject,
1841: NULL,
1842: ConfigData->Controller,
1843: SerialPhysicalZero,
1844: 0,
1845: 0,
1846: 0,
1847: 4,
1848: STATUS_SUCCESS,
1849: SERIAL_INSUFFICIENT_RESOURCES,
1850: 0,
1851: NULL,
1852: 0,
1853: NULL
1854: );
1855: ExFreePool(ConfigData->ObjectDirectory.Buffer);
1856: ExFreePool(ConfigData->NtNameForPort.Buffer);
1857: ExFreePool(ConfigData->SymbolicLinkName.Buffer);
1858: ExFreePool(ConfigData);
1859: return STATUS_INSUFFICIENT_RESOURCES;
1860:
1861: }
1862:
1863: //
1864: // Actually form the Name.
1865: //
1866:
1867: RtlZeroMemory(
1868: uniNameString.Buffer,
1869: uniNameString.MaximumLength
1870: );
1871:
1872: RtlAppendUnicodeToString(
1873: &uniNameString,
1874: L"\\Device\\"
1875: );
1876:
1877: RtlAppendUnicodeStringToString(
1878: &uniNameString,
1879: &ConfigData->NtNameForPort
1880: );
1881:
1882: //
1883: // Create the device object for this device.
1884: //
1885:
1886: status = IoCreateDevice(
1887: DriverObject,
1888: sizeof(SERIAL_DEVICE_EXTENSION),
1889: &uniNameString,
1890: FILE_DEVICE_SERIAL_PORT,
1891: 0,
1892: TRUE,
1893: &deviceObject
1894: );
1895:
1896: //
1897: // If we couldn't create the device object, then there
1898: // is no point in going on.
1899: //
1900:
1901: if (!NT_SUCCESS(status)) {
1902:
1903: SerialDump(
1904: SERERRORS,
1905: ("SERIAL: Could not create a device for %wZ\n",
1906: &ConfigData->NtNameForPort)
1907: );
1908: SerialLogError(
1909: DriverObject,
1910: NULL,
1911: ConfigData->Controller,
1912: SerialPhysicalZero,
1913: 0,
1914: 0,
1915: 0,
1916: 5,
1917: status,
1918: SERIAL_INSUFFICIENT_RESOURCES,
1919: 0,
1920: NULL,
1921: 0,
1922: NULL
1923: );
1924: ExFreePool(ConfigData->ObjectDirectory.Buffer);
1925: ExFreePool(ConfigData->NtNameForPort.Buffer);
1926: ExFreePool(ConfigData->SymbolicLinkName.Buffer);
1927: ExFreePool(ConfigData);
1928: ExFreePool(uniNameString.Buffer);
1929: return STATUS_INSUFFICIENT_RESOURCES;
1930:
1931: }
1932:
1933: //
1934: // The device object has a pointer to an area of non-paged
1935: // pool allocated for this device. This will be the device
1936: // extension.
1937: //
1938:
1939: extension = deviceObject->DeviceExtension;
1940:
1941: //
1942: // Zero all of the memory associated with the device
1943: // extension.
1944: //
1945:
1946: RtlZeroMemory(
1947: extension,
1948: sizeof(SERIAL_DEVICE_EXTENSION)
1949: );
1950:
1951: //
1952: // Propagate that it is a jensen.
1953: //
1954:
1955: extension->Jensen = ConfigData->Jensen;
1956:
1957: //
1958: // So far, we don't know if this extension will be
1959: // shareing it's interrupt object with any other serial
1960: // port.
1961: //
1962:
1963: InitializeListHead(&extension->TopLevelSharers);
1964: InitializeListHead(&extension->CommonInterruptObject);
1965:
1966: //
1967: // Save off our name.
1968: //
1969:
1970: RtlInitUnicodeString(
1971: &extension->DeviceName,
1972: NULL
1973: );
1974:
1975: extension->DeviceName.Length = uniNameString.Length;
1976: extension->DeviceName.MaximumLength = uniNameString.MaximumLength;
1977: extension->DeviceName.Buffer = uniNameString.Buffer;
1978:
1979: //
1980: // Just initialize the names so that we don't try
1981: // to "clean" them up if we cant intialize the
1982: // controller all the way.
1983: //
1984:
1985: RtlInitUnicodeString(
1986: &extension->ObjectDirectory,
1987: NULL
1988: );
1989: RtlInitUnicodeString(
1990: &extension->NtNameForPort,
1991: NULL
1992: );
1993: RtlInitUnicodeString(
1994: &extension->SymbolicLinkName,
1995: NULL
1996: );
1997:
1998: //
1999: // Initialize the list heads for the read, write, and mask queues.
2000: //
2001: // These lists will hold all of the queued IRP's for the device.
2002: //
2003:
2004: InitializeListHead(&extension->ReadQueue);
2005: InitializeListHead(&extension->WriteQueue);
2006: InitializeListHead(&extension->MaskQueue);
2007: InitializeListHead(&extension->PurgeQueue);
2008:
2009: //
2010: // Initialize the spinlock associated with fields read (& set)
2011: // by IO Control functions.
2012: //
2013:
2014: KeInitializeSpinLock(&extension->ControlLock);
2015:
2016: //
2017: // Initialize the timers used to timeout operations.
2018: //
2019:
2020: KeInitializeTimer(&extension->ReadRequestTotalTimer);
2021: KeInitializeTimer(&extension->ReadRequestIntervalTimer);
2022: KeInitializeTimer(&extension->WriteRequestTotalTimer);
2023: KeInitializeTimer(&extension->ImmediateTotalTimer);
2024: KeInitializeTimer(&extension->XoffCountTimer);
2025: KeInitializeTimer(&extension->LowerRTSTimer);
2026:
2027: //
2028: // Intialialize the dpcs that will be used to complete
2029: // or timeout various IO operations.
2030: //
2031:
2032: KeInitializeDpc(
2033: &extension->CompleteWriteDpc,
2034: SerialCompleteWrite,
2035: extension
2036: );
2037:
2038: KeInitializeDpc(
2039: &extension->CompleteReadDpc,
2040: SerialCompleteRead,
2041: extension
2042: );
2043:
2044: KeInitializeDpc(
2045: &extension->TotalReadTimeoutDpc,
2046: SerialReadTimeout,
2047: extension
2048: );
2049:
2050: KeInitializeDpc(
2051: &extension->IntervalReadTimeoutDpc,
2052: SerialIntervalReadTimeout,
2053: extension
2054: );
2055:
2056: KeInitializeDpc(
2057: &extension->TotalWriteTimeoutDpc,
2058: SerialWriteTimeout,
2059: extension
2060: );
2061:
2062: KeInitializeDpc(
2063: &extension->CommErrorDpc,
2064: SerialCommError,
2065: extension
2066: );
2067:
2068: KeInitializeDpc(
2069: &extension->CompleteImmediateDpc,
2070: SerialCompleteImmediate,
2071: extension
2072: );
2073:
2074: KeInitializeDpc(
2075: &extension->TotalImmediateTimeoutDpc,
2076: SerialTimeoutImmediate,
2077: extension
2078: );
2079:
2080: KeInitializeDpc(
2081: &extension->CommWaitDpc,
2082: SerialCompleteWait,
2083: extension
2084: );
2085:
2086: KeInitializeDpc(
2087: &extension->XoffCountTimeoutDpc,
2088: SerialTimeoutXoff,
2089: extension
2090: );
2091:
2092: KeInitializeDpc(
2093: &extension->XoffCountCompleteDpc,
2094: SerialCompleteXoff,
2095: extension
2096: );
2097:
2098: KeInitializeDpc(
2099: &extension->StartTimerLowerRTSDpc,
2100: SerialStartTimerLowerRTS,
2101: extension
2102: );
2103:
2104: KeInitializeDpc(
2105: &extension->PerhapsLowerRTSDpc,
2106: SerialInvokePerhapsLowerRTS,
2107: extension
2108: );
2109:
2110: if (!((ConfigData->ClockRate == 1843200) ||
2111: (ConfigData->ClockRate == 3072000) ||
2112: (ConfigData->ClockRate == 4233600) ||
2113: (ConfigData->ClockRate == 8000000))) {
2114:
2115: SerialLogError(
2116: extension->DeviceObject->DriverObject,
2117: extension->DeviceObject,
2118: ConfigData->Controller,
2119: SerialPhysicalZero,
2120: 0,
2121: 0,
2122: 0,
2123: 6,
2124: STATUS_SUCCESS,
2125: SERIAL_UNSUPPORTED_CLOCK_RATE,
2126: ConfigData->SymbolicLinkName.Length+sizeof(WCHAR),
2127: ConfigData->SymbolicLinkName.Buffer,
2128: 0,
2129: NULL
2130: );
2131: SerialDump(
2132: SERERRORS,
2133: ("SERIAL: Invalid clock rate specified for %wZ\n",
2134: &ConfigData->NtNameForPort)
2135: );
2136: status = STATUS_SERIAL_NO_DEVICE_INITED;
2137: goto ExtensionCleanup;
2138:
2139: }
2140:
2141: //
2142: // Save the value of clock input to the part. We use this to calculate
2143: // the divisor latch value. The value is in Hertz.
2144: //
2145:
2146: extension->ClockRate = ConfigData->ClockRate;
2147:
2148: //
2149: // Get a "back pointer" to the device object and specify
2150: // that this driver only supports buffered IO. This basically
2151: // means that the IO system copies the users data to and from
2152: // system supplied buffers.
2153: //
2154:
2155: extension->DeviceObject = deviceObject;
2156: deviceObject->Flags |= DO_BUFFERED_IO;
2157:
2158: //
2159: // Map the memory for the control registers for the serial device
2160: // into virtual memory.
2161: //
2162:
2163: extension->Controller = SerialGetMappedAddress(
2164: ConfigData->InterfaceType,
2165: ConfigData->BusNumber,
2166: ConfigData->Controller,
2167: ConfigData->SpanOfController,
2168: (BOOLEAN)ConfigData->AddressSpace,
2169: &extension->UnMapRegisters
2170: );
2171:
2172:
2173: if (!extension->Controller) {
2174:
2175: SerialLogError(
2176: extension->DeviceObject->DriverObject,
2177: extension->DeviceObject,
2178: ConfigData->Controller,
2179: SerialPhysicalZero,
2180: 0,
2181: 0,
2182: 0,
2183: 7,
2184: STATUS_SUCCESS,
2185: SERIAL_REGISTERS_NOT_MAPPED,
2186: ConfigData->SymbolicLinkName.Length+sizeof(WCHAR),
2187: ConfigData->SymbolicLinkName.Buffer,
2188: 0,
2189: NULL
2190: );
2191: SerialDump(
2192: SERERRORS,
2193: ("SERIAL: Could not map memory for device registers for %wZ\n",
2194: &ConfigData->NtNameForPort)
2195: );
2196: extension->UnMapRegisters = FALSE;
2197: status = STATUS_NONE_MAPPED;
2198: goto ExtensionCleanup;
2199:
2200: }
2201:
2202: extension->AddressSpace = ConfigData->AddressSpace;
2203: extension->OriginalController = ConfigData->Controller;
2204: extension->SpanOfController = ConfigData->SpanOfController;
2205:
2206: //
2207: // if we were requested to map the interrupt status do so.
2208: //
2209:
2210: if (MapInterruptStatus) {
2211:
2212: extension->InterruptStatus = SerialGetMappedAddress(
2213: ConfigData->InterfaceType,
2214: ConfigData->BusNumber,
2215: ConfigData->InterruptStatus,
2216: ConfigData->SpanOfInterruptStatus,
2217: (BOOLEAN)ConfigData->AddressSpace,
2218: &extension->UnMapStatus
2219: );
2220:
2221:
2222: if (!extension->InterruptStatus) {
2223:
2224: SerialLogError(
2225: extension->DeviceObject->DriverObject,
2226: extension->DeviceObject,
2227: ConfigData->Controller,
2228: SerialPhysicalZero,
2229: 0,
2230: 0,
2231: 0,
2232: 8,
2233: STATUS_SUCCESS,
2234: SERIAL_REGISTERS_NOT_MAPPED,
2235: ConfigData->SymbolicLinkName.Length+sizeof(WCHAR),
2236: ConfigData->SymbolicLinkName.Buffer,
2237: 0,
2238: NULL
2239: );
2240: SerialDump(
2241: SERERRORS,
2242: ("SERIAL: Could not map memory for interrupt status for %wZ\n",
2243: &ConfigData->NtNameForPort)
2244: );
2245: extension->UnMapRegisters = FALSE;
2246: status = STATUS_NONE_MAPPED;
2247: goto ExtensionCleanup;
2248:
2249: }
2250:
2251: extension->OriginalInterruptStatus = ConfigData->InterruptStatus;
2252: extension->SpanOfInterruptStatus = ConfigData->SpanOfInterruptStatus;
2253:
2254: }
2255:
2256: //
2257: // For now, assume that unless we are on a MicroChannel
2258: // machine the interrupt isn't shareable.
2259: //
2260: // BUG BUG Is there some EISA data out there that will
2261: // BUG BUG tell us whether the card is a true EISA card?
2262: //
2263:
2264: if (ConfigData->InterfaceType == MicroChannel) {
2265:
2266: extension->InterruptShareable = TRUE;
2267:
2268: } else {
2269:
2270: extension->InterruptShareable = FALSE;
2271:
2272: }
2273:
2274: //
2275: // Save off the interface type and the bus number.
2276: //
2277:
2278: extension->InterfaceType = ConfigData->InterfaceType;
2279: extension->BusNumber = ConfigData->BusNumber;
2280:
2281: //
2282: // From the Hal, get the interrupt vector and level.
2283: //
2284:
2285: extension->InterruptMode = ConfigData->InterruptMode;
2286: extension->OriginalIrql = ConfigData->OriginalIrql;
2287: extension->OriginalVector = ConfigData->OriginalVector;
2288: extension->Vector = HalGetInterruptVector(
2289: ConfigData->InterfaceType,
2290: ConfigData->BusNumber,
2291: ConfigData->OriginalIrql,
2292: ConfigData->OriginalVector,
2293: &extension->Irql,
2294: &extension->ProcessorAffinity
2295: );
2296:
2297: //
2298: // Report it's resources. We do this now because we are just
2299: // about to touch the resources for the first time.
2300: //
2301:
2302: SerialReportResourcesDevice(
2303: extension,
2304: &conflictDetected
2305: );
2306:
2307: if (conflictDetected) {
2308:
2309: SerialDump(
2310: SERERRORS,
2311: ("SERIAL: Reporting resources for %wZ with extension %x\n"
2312: "------- detected a conflict\n",
2313: &extension->NtNameForPort,extension)
2314: );
2315: SerialLogError(
2316: extension->DeviceObject->DriverObject,
2317: extension->DeviceObject,
2318: ConfigData->Controller,
2319: SerialPhysicalZero,
2320: 0,
2321: 0,
2322: 0,
2323: 9,
2324: STATUS_SUCCESS,
2325: SERIAL_RESOURCE_CONFLICT,
2326: ConfigData->SymbolicLinkName.Length+sizeof(WCHAR),
2327: ConfigData->SymbolicLinkName.Buffer,
2328: 0,
2329: NULL
2330: );
2331:
2332: //
2333: // This status won't propagate far.
2334: //
2335:
2336: status = STATUS_INSUFFICIENT_RESOURCES;
2337: goto ExtensionCleanup;
2338:
2339: }
2340:
2341: reportedResources = TRUE;
2342:
2343: //
2344: // Before we test whether the port exists (which will enable the FIFO)
2345: // convert the rx trigger value to what should be used in the register.
2346: //
2347: // If a bogus value was given - crank them down to 1.
2348: //
2349:
2350: switch (ConfigData->RxFIFO) {
2351:
2352: case 1:
2353:
2354: extension->RxFifoTrigger = SERIAL_1_BYTE_HIGH_WATER;
2355: break;
2356:
2357: case 4:
2358:
2359: extension->RxFifoTrigger = SERIAL_4_BYTE_HIGH_WATER;
2360: break;
2361:
2362: case 8:
2363:
2364: extension->RxFifoTrigger = SERIAL_8_BYTE_HIGH_WATER;
2365: break;
2366:
2367: case 14:
2368:
2369: extension->RxFifoTrigger = SERIAL_14_BYTE_HIGH_WATER;
2370: break;
2371:
2372: default:
2373:
2374: extension->RxFifoTrigger = SERIAL_1_BYTE_HIGH_WATER;
2375: break;
2376:
2377: }
2378:
2379: if (!SerialDoesPortExist(
2380: extension,
2381: &ConfigData->SymbolicLinkName,
2382: ConfigData->ForceFifoEnable
2383: )) {
2384:
2385: //
2386: // We couldn't verify that there was actually a
2387: // port. No need to log an error as the port exist
2388: // code will log exactly why.
2389: //
2390:
2391: SerialDump(
2392: SERERRORS,
2393: ("SERIAL: Does Port exist test failed for %wZ\n",
2394: &ConfigData->NtNameForPort)
2395: );
2396: status = STATUS_NO_SUCH_DEVICE;
2397: goto ExtensionCleanup;
2398:
2399: }
2400:
2401: //
2402: // If the user requested that we disable the port, then
2403: // do it now. Log the fact that the port has been disabled.
2404: //
2405:
2406: if (ConfigData->DisablePort) {
2407:
2408: SerialDump(
2409: SERERRORS,
2410: ("SERIAL: disabled port %wZ as requested in configuration\n",
2411: &ConfigData->NtNameForPort)
2412: );
2413: status = STATUS_NO_SUCH_DEVICE;
2414: SerialLogError(
2415: extension->DeviceObject->DriverObject,
2416: extension->DeviceObject,
2417: ConfigData->Controller,
2418: SerialPhysicalZero,
2419: 0,
2420: 0,
2421: 0,
2422: 57,
2423: STATUS_SUCCESS,
2424: SERIAL_DISABLED_PORT,
2425: ConfigData->SymbolicLinkName.Length+sizeof(WCHAR),
2426: ConfigData->SymbolicLinkName.Buffer,
2427: 0,
2428: NULL
2429: );
2430: goto ExtensionCleanup;
2431:
2432: }
2433:
2434:
2435:
2436: //
2437: // Set up the default device control fields.
2438: // Note that if the values are changed after
2439: // the file is open, they do NOT revert back
2440: // to the old value at file close.
2441: //
2442:
2443: extension->SpecialChars.XonChar = SERIAL_DEF_XON;
2444: extension->SpecialChars.XoffChar = SERIAL_DEF_XOFF;
2445: extension->HandFlow.ControlHandShake = SERIAL_DTR_CONTROL;
2446:
2447: extension->HandFlow.FlowReplace = SERIAL_RTS_CONTROL;
2448:
2449: //
2450: // Default Line control protocol. 7E1
2451: //
2452: // Seven data bits.
2453: // Even parity.
2454: // 1 Stop bits.
2455: //
2456:
2457: extension->LineControl = SERIAL_7_DATA |
2458: SERIAL_EVEN_PARITY |
2459: SERIAL_NONE_PARITY;
2460:
2461: extension->ValidDataMask = 0x7f;
2462: extension->CurrentBaud = 1200;
2463:
2464:
2465: //
2466: // We set up the default xon/xoff limits.
2467: //
2468:
2469: extension->HandFlow.XoffLimit = extension->BufferSize >> 3;
2470: extension->HandFlow.XonLimit = extension->BufferSize >> 1;
2471:
2472: extension->BufferSizePt8 = ((3*(extension->BufferSize>>2))+
2473: (extension->BufferSize>>4));
2474:
2475: SerialDump(
2476: SERDIAG1,
2477: ("SERIAL: The default interrupt read buffer size is: %d\n"
2478: "------ The XoffLimit is : %d\n"
2479: "------ The XonLimit is : %d\n"
2480: "------ The pt 8 size is : %d\n",
2481: extension->BufferSize,
2482: extension->HandFlow.XoffLimit,
2483: extension->HandFlow.XonLimit,
2484: extension->BufferSizePt8)
2485: );
2486:
2487: //
2488: // Go through all the "named" baud rates to find out which ones
2489: // can be supported with this port.
2490: //
2491:
2492: extension->SupportedBauds = SERIAL_BAUD_USER;
2493:
2494: {
2495:
2496: SHORT junk;
2497:
2498: if (!NT_ERROR(SerialGetDivisorFromBaud(
2499: extension->ClockRate,
2500: (LONG)75,
2501: &junk
2502: ))) {
2503:
2504: extension->SupportedBauds |= SERIAL_BAUD_075;
2505:
2506: }
2507:
2508: if (!NT_ERROR(SerialGetDivisorFromBaud(
2509: extension->ClockRate,
2510: (LONG)110,
2511: &junk
2512: ))) {
2513:
2514: extension->SupportedBauds |= SERIAL_BAUD_110;
2515:
2516: }
2517:
2518: if (!NT_ERROR(SerialGetDivisorFromBaud(
2519: extension->ClockRate,
2520: (LONG)135,
2521: &junk
2522: ))) {
2523:
2524: extension->SupportedBauds |= SERIAL_BAUD_134_5;
2525:
2526: }
2527:
2528: if (!NT_ERROR(SerialGetDivisorFromBaud(
2529: extension->ClockRate,
2530: (LONG)150,
2531: &junk
2532: ))) {
2533:
2534: extension->SupportedBauds |= SERIAL_BAUD_150;
2535:
2536: }
2537:
2538: if (!NT_ERROR(SerialGetDivisorFromBaud(
2539: extension->ClockRate,
2540: (LONG)300,
2541: &junk
2542: ))) {
2543:
2544: extension->SupportedBauds |= SERIAL_BAUD_300;
2545:
2546: }
2547:
2548: if (!NT_ERROR(SerialGetDivisorFromBaud(
2549: extension->ClockRate,
2550: (LONG)600,
2551: &junk
2552: ))) {
2553:
2554: extension->SupportedBauds |= SERIAL_BAUD_600;
2555:
2556: }
2557:
2558: if (!NT_ERROR(SerialGetDivisorFromBaud(
2559: extension->ClockRate,
2560: (LONG)1200,
2561: &junk
2562: ))) {
2563:
2564: extension->SupportedBauds |= SERIAL_BAUD_1200;
2565:
2566: }
2567:
2568: if (!NT_ERROR(SerialGetDivisorFromBaud(
2569: extension->ClockRate,
2570: (LONG)1800,
2571: &junk
2572: ))) {
2573:
2574: extension->SupportedBauds |= SERIAL_BAUD_1800;
2575:
2576: }
2577:
2578: if (!NT_ERROR(SerialGetDivisorFromBaud(
2579: extension->ClockRate,
2580: (LONG)2400,
2581: &junk
2582: ))) {
2583:
2584: extension->SupportedBauds |= SERIAL_BAUD_2400;
2585:
2586: }
2587:
2588: if (!NT_ERROR(SerialGetDivisorFromBaud(
2589: extension->ClockRate,
2590: (LONG)4800,
2591: &junk
2592: ))) {
2593:
2594: extension->SupportedBauds |= SERIAL_BAUD_4800;
2595:
2596: }
2597:
2598: if (!NT_ERROR(SerialGetDivisorFromBaud(
2599: extension->ClockRate,
2600: (LONG)7200,
2601: &junk
2602: ))) {
2603:
2604: extension->SupportedBauds |= SERIAL_BAUD_7200;
2605:
2606: }
2607:
2608: if (!NT_ERROR(SerialGetDivisorFromBaud(
2609: extension->ClockRate,
2610: (LONG)9600,
2611: &junk
2612: ))) {
2613:
2614: extension->SupportedBauds |= SERIAL_BAUD_9600;
2615:
2616: }
2617:
2618: if (!NT_ERROR(SerialGetDivisorFromBaud(
2619: extension->ClockRate,
2620: (LONG)14400,
2621: &junk
2622: ))) {
2623:
2624: extension->SupportedBauds |= SERIAL_BAUD_14400;
2625:
2626: }
2627:
2628: if (!NT_ERROR(SerialGetDivisorFromBaud(
2629: extension->ClockRate,
2630: (LONG)19200,
2631: &junk
2632: ))) {
2633:
2634: extension->SupportedBauds |= SERIAL_BAUD_19200;
2635:
2636: }
2637:
2638: if (!NT_ERROR(SerialGetDivisorFromBaud(
2639: extension->ClockRate,
2640: (LONG)38400,
2641: &junk
2642: ))) {
2643:
2644: extension->SupportedBauds |= SERIAL_BAUD_38400;
2645:
2646: }
2647:
2648: if (!NT_ERROR(SerialGetDivisorFromBaud(
2649: extension->ClockRate,
2650: (LONG)56000,
2651: &junk
2652: ))) {
2653:
2654: extension->SupportedBauds |= SERIAL_BAUD_56K;
2655:
2656: }
2657: if (!NT_ERROR(SerialGetDivisorFromBaud(
2658: extension->ClockRate,
2659: (LONG)57600,
2660: &junk
2661: ))) {
2662:
2663: extension->SupportedBauds |= SERIAL_BAUD_57600;
2664:
2665: }
2666: if (!NT_ERROR(SerialGetDivisorFromBaud(
2667: extension->ClockRate,
2668: (LONG)115200,
2669: &junk
2670: ))) {
2671:
2672: extension->SupportedBauds |= SERIAL_BAUD_115200;
2673:
2674: }
2675:
2676: if (!NT_ERROR(SerialGetDivisorFromBaud(
2677: extension->ClockRate,
2678: (LONG)128000,
2679: &junk
2680: ))) {
2681:
2682: extension->SupportedBauds |= SERIAL_BAUD_128K;
2683:
2684: }
2685:
2686: }
2687:
2688:
2689: //
2690: // Mark this device as not being opened by anyone. We keep a
2691: // variable around so that spurious interrupts are easily
2692: // dismissed by the ISR.
2693: //
2694:
2695: extension->DeviceIsOpened = FALSE;
2696:
2697: //
2698: // This call will set up the naming necessary for
2699: // external applications to get to the driver. It
2700: // will also set up the device map.
2701: //
2702:
2703:
2704: extension->ObjectDirectory = ConfigData->ObjectDirectory;
2705: extension->NtNameForPort = ConfigData->NtNameForPort;
2706: extension->SymbolicLinkName = ConfigData->SymbolicLinkName;
2707: SerialSetupExternalNaming(extension);
2708:
2709: //
2710: // Store values into the extension for interval timing.
2711: //
2712:
2713: //
2714: // If the interval timer is less than a second then come
2715: // in with a short "polling" loop.
2716: //
2717: // For large (> then 2 seconds) use a 1 second poller.
2718: //
2719:
2720: extension->ShortIntervalAmount.LowPart = 1;
2721: extension->ShortIntervalAmount.HighPart = 0;
2722: extension->ShortIntervalAmount = RtlLargeIntegerNegate(
2723: extension->ShortIntervalAmount
2724: );
2725: extension->LongIntervalAmount.LowPart = 10000000;
2726: extension->LongIntervalAmount.HighPart = 0;
2727: extension->LongIntervalAmount = RtlLargeIntegerNegate(
2728: extension->LongIntervalAmount
2729: );
2730: extension->CutOverAmount.LowPart = 200000000;
2731: extension->CutOverAmount.HighPart = 0;
2732:
2733:
2734: //
2735: // Pass pack the extension to the caller.
2736: //
2737:
2738: *DeviceExtension = extension;
2739:
2740: //
2741: // Common error path cleanup. If the status is
2742: // bad, get rid of the device extension, device object
2743: // and any memory associated with it.
2744: //
2745:
2746: ExtensionCleanup: ;
2747:
2748: ExFreePool(ConfigData);
2749:
2750: if (NT_ERROR(status)) {
2751:
2752: if (extension) {
2753:
2754: if (reportedResources) {
2755:
2756: SerialUnReportResourcesDevice(extension);
2757:
2758: }
2759:
2760: SerialCleanupDevice(extension);
2761: IoDeleteDevice(deviceObject);
2762:
2763: }
2764:
2765: }
2766:
2767: return status;
2768:
2769: }
2770:
2771: BOOLEAN
2772: SerialDoesPortExist(
2773: IN PSERIAL_DEVICE_EXTENSION Extension,
2774: IN PUNICODE_STRING InsertString,
2775: IN ULONG ForceFifo
2776: )
2777:
2778: /*++
2779:
2780: Routine Description:
2781:
2782: This routine examines several of what might be the serial device
2783: registers. It ensures that the bits that should be zero are zero.
2784:
2785: In addition, this routine will determine if the device supports
2786: fifo's. If it does it will enable the fifo's and turn on a boolean
2787: in the extension that indicates the fifo's presence.
2788:
2789: NOTE: If there is indeed a serial port at the address specified
2790: it will absolutely have interrupts inhibited upon return
2791: from this routine.
2792:
2793: NOTE: Since this routine should be called fairly early in
2794: the device driver initialization, the only element
2795: that needs to be filled in is the base register address.
2796:
2797: NOTE: These tests all assume that this code is the only
2798: code that is looking at these ports or this memory.
2799:
2800: This is a not to unreasonable assumption even on
2801: multiprocessor systems.
2802:
2803: Arguments:
2804:
2805: Extension - A pointer to a serial device extension.
2806: InsertString - String to place in an error log entry.
2807: ForceFifo - !0 forces the fifo to be left on if found.
2808:
2809: Return Value:
2810:
2811: Will return true if the port really exists, otherwise it
2812: will return false.
2813:
2814: --*/
2815:
2816: {
2817:
2818:
2819: UCHAR regContents;
2820: BOOLEAN returnValue = TRUE;
2821: UCHAR oldIERContents;
2822: UCHAR oldLCRContents;
2823: USHORT value1;
2824: USHORT value2;
2825: KIRQL oldIrql;
2826:
2827:
2828: //
2829: // Save of the line control.
2830: //
2831:
2832: oldLCRContents = READ_LINE_CONTROL(Extension->Controller);
2833:
2834: //
2835: // Make sure that we are *aren't* accessing the divsior latch.
2836: //
2837:
2838: WRITE_LINE_CONTROL(
2839: Extension->Controller,
2840: (UCHAR)(oldLCRContents & ~SERIAL_LCR_DLAB)
2841: );
2842:
2843: oldIERContents = READ_INTERRUPT_ENABLE(Extension->Controller);
2844:
2845: //
2846: // Go up to power level for a very short time to prevent
2847: // any interrupts from this device from coming in.
2848: //
2849:
2850: KeRaiseIrql(
2851: POWER_LEVEL,
2852: &oldIrql
2853: );
2854:
2855: WRITE_INTERRUPT_ENABLE(
2856: Extension->Controller,
2857: 0x0f
2858: );
2859:
2860: value1 = READ_INTERRUPT_ENABLE(Extension->Controller);
2861: value1 = value1 << 8;
2862: value1 |= READ_RECEIVE_BUFFER(Extension->Controller);
2863:
2864: READ_DIVISOR_LATCH(
2865: Extension->Controller,
2866: &value2
2867: );
2868:
2869: WRITE_LINE_CONTROL(
2870: Extension->Controller,
2871: oldLCRContents
2872: );
2873:
2874: //
2875: // Put the ier back to where it was before. If we are on a
2876: // level sensitive port this should prevent the interrupts
2877: // from coming in. If we are on a latched, we don't care
2878: // cause the interrupts generated will just get dropped.
2879: //
2880:
2881: WRITE_INTERRUPT_ENABLE(
2882: Extension->Controller,
2883: oldIERContents
2884: );
2885:
2886: KeLowerIrql(oldIrql);
2887:
2888: if (value1 == value2) {
2889:
2890: SerialLogError(
2891: Extension->DeviceObject->DriverObject,
2892: Extension->DeviceObject,
2893: Extension->OriginalController,
2894: SerialPhysicalZero,
2895: 0,
2896: 0,
2897: 0,
2898: 62,
2899: STATUS_SUCCESS,
2900: SERIAL_DLAB_INVALID,
2901: InsertString->Length+sizeof(WCHAR),
2902: InsertString->Buffer,
2903: 0,
2904: NULL
2905: );
2906: returnValue = FALSE;
2907: goto AllDone;
2908:
2909: }
2910:
2911: AllDone: ;
2912:
2913:
2914: //
2915: // If we think that there is a serial device then we determine
2916: // if a fifo is present.
2917: //
2918:
2919: if (returnValue) {
2920:
2921: //
2922: // Well, we think it's a serial device. Absolutely
2923: // positively, prevent interrupts from occuring.
2924: //
2925: // We disable all the interrupt enable bits, and
2926: // push down all the lines in the modem control
2927: // We only needed to push down OUT2 which in
2928: // PC's must also be enabled to get an interrupt.
2929: //
2930:
2931: DISABLE_ALL_INTERRUPTS(Extension->Controller);
2932:
2933: if (Extension->Jensen) {
2934:
2935: WRITE_MODEM_CONTROL(
2936: Extension->Controller,
2937: (UCHAR)SERIAL_MCR_OUT2
2938: );
2939:
2940: } else {
2941:
2942: WRITE_MODEM_CONTROL(
2943: Extension->Controller,
2944: (UCHAR)0
2945: );
2946:
2947: }
2948:
2949: //
2950: // See if this is a 16550. We do this by writing to
2951: // what would be the fifo control register with a bit
2952: // pattern that tells the device to enable fifo's.
2953: // We then read the iterrupt Id register to see if the
2954: // bit pattern is present that identifies the 16550.
2955: //
2956:
2957: WRITE_FIFO_CONTROL(
2958: Extension->Controller,
2959: SERIAL_FCR_ENABLE
2960: );
2961:
2962: regContents = READ_INTERRUPT_ID_REG(Extension->Controller);
2963:
2964: if (regContents & SERIAL_IIR_FIFOS_ENABLED) {
2965:
2966: //
2967: // Save off that the device supports fifos.
2968: //
2969:
2970: Extension->FifoPresent = TRUE;
2971:
2972: //
2973: // There are fifos on this card. Set the value of the
2974: // receive fifo to interrupt when 4 characters are present.
2975: //
2976:
2977: WRITE_FIFO_CONTROL(
2978: Extension->Controller,
2979: (UCHAR)(SERIAL_FCR_ENABLE | Extension->RxFifoTrigger |
2980: SERIAL_FCR_RCVR_RESET | SERIAL_FCR_TXMT_RESET)
2981: );
2982:
2983: }
2984:
2985: if (!ForceFifo) {
2986:
2987: Extension->FifoPresent = FALSE;
2988: WRITE_FIFO_CONTROL(
2989: Extension->Controller,
2990: (UCHAR)0
2991: );
2992:
2993: }
2994:
2995: if (Extension->FifoPresent) {
2996:
2997: SerialLogError(
2998: Extension->DeviceObject->DriverObject,
2999: Extension->DeviceObject,
3000: Extension->OriginalController,
3001: SerialPhysicalZero,
3002: 0,
3003: 0,
3004: 0,
3005: 15,
3006: STATUS_SUCCESS,
3007: SERIAL_FIFO_PRESENT,
3008: InsertString->Length+sizeof(WCHAR),
3009: InsertString->Buffer,
3010: 0,
3011: NULL
3012: );
3013:
3014: SerialDump(
3015: SERDIAG1,
3016: ("SERIAL: Fifo's detected at port address: %x\n",
3017: Extension->Controller)
3018: );
3019:
3020: }
3021:
3022: //
3023: // In case we are dealing with a bitmasked multiportcard,
3024: // that has the mask register enabled, enable all
3025: // interrupts.
3026: //
3027:
3028: if (Extension->InterruptStatus) {
3029:
3030: WRITE_PORT_UCHAR(
3031: Extension->InterruptStatus,
3032: (UCHAR)0xff
3033: );
3034:
3035: }
3036:
3037: }
3038:
3039: return returnValue;
3040:
3041: }
3042:
3043: BOOLEAN
3044: SerialReset(
3045: IN PVOID Context
3046: )
3047:
3048: /*++
3049:
3050: Routine Description:
3051:
3052: This places the hardware in a standard configuration.
3053:
3054: NOTE: This assumes that it is called at interrupt level.
3055:
3056:
3057: Arguments:
3058:
3059: Context - The device extension for serial device
3060: being managed.
3061:
3062: Return Value:
3063:
3064: Always FALSE.
3065:
3066: --*/
3067:
3068: {
3069:
3070: PSERIAL_DEVICE_EXTENSION extension = Context;
3071: UCHAR regContents;
3072: UCHAR oldModemControl;
3073: ULONG i;
3074:
3075: //
3076: // Deal with the out2 bit.
3077: // This will also prevent any interrupts from occuring.
3078: //
3079:
3080: oldModemControl = READ_MODEM_CONTROL(extension->Controller);
3081:
3082: if (extension->Jensen) {
3083:
3084: WRITE_MODEM_CONTROL(
3085: extension->Controller,
3086: (UCHAR)(oldModemControl | SERIAL_MCR_OUT2)
3087: );
3088:
3089: } else {
3090:
3091:
3092: WRITE_MODEM_CONTROL(
3093: extension->Controller,
3094: (UCHAR)(oldModemControl & ~SERIAL_MCR_OUT2)
3095: );
3096:
3097: }
3098:
3099: //
3100: // Reset the fifo's if there are any.
3101: //
3102:
3103: if (extension->FifoPresent) {
3104:
3105: WRITE_FIFO_CONTROL(
3106: extension->Controller,
3107: SERIAL_FCR_ENABLE
3108: );
3109: WRITE_FIFO_CONTROL(
3110: extension->Controller,
3111: (UCHAR)(SERIAL_FCR_ENABLE | extension->RxFifoTrigger |
3112: SERIAL_FCR_RCVR_RESET | SERIAL_FCR_TXMT_RESET)
3113: );
3114:
3115: }
3116:
3117: //
3118: // Make sure that the line control set up correct.
3119: //
3120: // 1) Make sure that the Divisor latch select is set
3121: // up to select the transmit and receive register.
3122: //
3123: // 2) Make sure that we aren't in a break state.
3124: //
3125:
3126: regContents = READ_LINE_CONTROL(extension->Controller);
3127: regContents &= ~(SERIAL_LCR_DLAB | SERIAL_LCR_BREAK);
3128:
3129: WRITE_LINE_CONTROL(
3130: extension->Controller,
3131: regContents
3132: );
3133:
3134: //
3135: // Read the receive buffer until the line status is
3136: // clear. (Actually give up after a 5 reads.)
3137: //
3138:
3139: for (i = 0;
3140: i < 5;
3141: i++
3142: ) {
3143:
3144: READ_RECEIVE_BUFFER(extension->Controller);
3145: if (!(READ_LINE_STATUS(extension->Controller) & 1)) {
3146:
3147: break;
3148:
3149: }
3150:
3151: }
3152:
3153: //
3154: // Read the modem status until the low 4 bits are
3155: // clear. (Actually give up after a 5 reads.)
3156: //
3157:
3158: for (i = 0;
3159: i < 1000;
3160: i++
3161: ) {
3162:
3163: if (!(READ_MODEM_STATUS(extension->Controller) & 0x0f)) {
3164:
3165: break;
3166:
3167: }
3168:
3169: }
3170:
3171: //
3172: // Now we set the line control, modem control, and the
3173: // baud to what they should be.
3174: //
3175:
3176: SerialSetLineControl(extension);
3177:
3178: SerialSetupNewHandFlow(
3179: extension,
3180: &extension->HandFlow
3181: );
3182:
3183: SerialHandleModemUpdate(
3184: extension,
3185: FALSE
3186: );
3187:
3188: {
3189: SHORT appropriateDivisor;
3190: SERIAL_IOCTL_SYNC s;
3191:
3192: SerialGetDivisorFromBaud(
3193: extension->ClockRate,
3194: extension->CurrentBaud,
3195: &appropriateDivisor
3196: );
3197: s.Extension = extension;
3198: s.Data = (PVOID)appropriateDivisor;
3199: SerialSetBaud(&s);
3200: }
3201:
3202: //
3203: // Enable which interrupts we want to receive.
3204: //
3205: // NOTE NOTE: This does not actually let interrupts
3206: // occur. We must still raise the OUT2 bit in the
3207: // modem control register. We will do that on open.
3208: //
3209:
3210: ENABLE_ALL_INTERRUPTS(extension->Controller);
3211:
3212: //
3213: // Read the interrupt id register until the low bit is
3214: // set. (Actually give up after a 5 reads.)
3215: //
3216:
3217: for (i = 0;
3218: i < 5;
3219: i++
3220: ) {
3221:
3222: if (READ_INTERRUPT_ID_REG(extension->Controller) & 0x01) {
3223:
3224: break;
3225:
3226: }
3227:
3228: }
3229:
3230: //
3231: // Now we know that nothing could be transmitting at this point
3232: // so we set the HoldingEmpty indicator.
3233: //
3234:
3235: extension->HoldingEmpty = TRUE;
3236:
3237: return FALSE;
3238: }
3239:
3240: NTSTATUS
3241: SerialGetDivisorFromBaud(
3242: IN ULONG ClockRate,
3243: IN LONG DesiredBaud,
3244: OUT PSHORT AppropriateDivisor
3245: )
3246:
3247: /*++
3248:
3249: Routine Description:
3250:
3251: This routine will determine a divisor based on an unvalidated
3252: baud rate.
3253:
3254: Arguments:
3255:
3256: ClockRate - The clock input to the controller.
3257:
3258: DesiredBaud - The baud rate for whose divisor we seek.
3259:
3260: AppropriateDivisor - Given that the DesiredBaud is valid, the
3261: LONG pointed to by this parameter will be set to the appropriate
3262: value. NOTE: The long is undefined if the DesiredBaud is not
3263: supported.
3264:
3265: Return Value:
3266:
3267: This function will return STATUS_SUCCESS if the baud is supported.
3268: If the value is not supported it will return a status such that
3269: NT_ERROR(Status) == FALSE.
3270:
3271: --*/
3272:
3273: {
3274:
3275: NTSTATUS status = STATUS_SUCCESS;
3276: SHORT calculatedDivisor;
3277: ULONG denominator;
3278: ULONG remainder;
3279:
3280: //
3281: // Allow up to a 1 percent error
3282: //
3283:
3284: ULONG maxRemain18 = 18432;
3285: ULONG maxRemain30 = 30720;
3286: ULONG maxRemain42 = 42336;
3287: ULONG maxRemain80 = 80000;
3288: ULONG maxRemain;
3289:
3290: //
3291: // Reject any non-positive bauds.
3292: //
3293:
3294: denominator = DesiredBaud*(ULONG)16;
3295:
3296: if (DesiredBaud <= 0) {
3297:
3298: *AppropriateDivisor = -1;
3299:
3300: } else if ((LONG)denominator < DesiredBaud) {
3301:
3302: //
3303: // If the desired baud was so huge that it cause the denominator
3304: // calculation to wrap, don't support it.
3305: //
3306:
3307: *AppropriateDivisor = -1;
3308:
3309: } else {
3310:
3311: if (ClockRate == 1843200) {
3312: maxRemain = maxRemain18;
3313: } else if (ClockRate == 3072000) {
3314: maxRemain = maxRemain30;
3315: } else if (ClockRate == 4233600) {
3316: maxRemain = maxRemain42;
3317: } else {
3318: maxRemain = maxRemain80;
3319: }
3320:
3321: calculatedDivisor = (SHORT)(ClockRate / denominator);
3322: remainder = ClockRate % denominator;
3323:
3324: //
3325: // Round up.
3326: //
3327:
3328: if (((remainder*2) > ClockRate) && (DesiredBaud != 110)) {
3329:
3330: calculatedDivisor++;
3331: }
3332:
3333:
3334: //
3335: // Only let the remainder calculations effect us if
3336: // the baud rate is > 9600.
3337: //
3338:
3339: if (DesiredBaud >= 9600) {
3340:
3341: //
3342: // If the remainder is less than the maximum remainder (wrt
3343: // the ClockRate) or the remainder + the maximum remainder is
3344: // greater than or equal to the ClockRate then assume that the
3345: // baud is ok.
3346: //
3347:
3348: if ((remainder >= maxRemain) && ((remainder+maxRemain) < ClockRate)) {
3349: calculatedDivisor = -1;
3350: }
3351:
3352: }
3353:
3354: //
3355: // Don't support a baud that causes the denominator to
3356: // be larger than the clock.
3357: //
3358:
3359: if (denominator > ClockRate) {
3360:
3361: calculatedDivisor = -1;
3362:
3363: }
3364:
3365: //
3366: // Ok, Now do some special casing so that things can actually continue
3367: // working on all platforms.
3368: //
3369:
3370: if (ClockRate == 1843200) {
3371:
3372: if (DesiredBaud == 56000) {
3373: calculatedDivisor = 2;
3374: }
3375:
3376: } else if (ClockRate == 3072000) {
3377:
3378: if (DesiredBaud == 14400) {
3379: calculatedDivisor = 13;
3380: }
3381:
3382: } else if (ClockRate == 4233600) {
3383:
3384: if (DesiredBaud == 9600) {
3385: calculatedDivisor = 28;
3386: } else if (DesiredBaud == 14400) {
3387: calculatedDivisor = 18;
3388: } else if (DesiredBaud == 19200) {
3389: calculatedDivisor = 14;
3390: } else if (DesiredBaud == 38400) {
3391: calculatedDivisor = 7;
3392: } else if (DesiredBaud == 56000) {
3393: calculatedDivisor = 5;
3394: }
3395:
3396: } else if (ClockRate == 8000000) {
3397:
3398: if (DesiredBaud == 14400) {
3399: calculatedDivisor = 35;
3400: } else if (DesiredBaud == 56000) {
3401: calculatedDivisor = 9;
3402: }
3403:
3404: }
3405:
3406: *AppropriateDivisor = calculatedDivisor;
3407:
3408: }
3409:
3410:
3411: if (*AppropriateDivisor == -1) {
3412:
3413: status = STATUS_INVALID_PARAMETER;
3414:
3415: }
3416:
3417: return status;
3418:
3419: }
3420:
3421: VOID
3422: SerialUnload(
3423: IN PDRIVER_OBJECT DriverObject
3424: )
3425:
3426: /*++
3427:
3428: Routine Description:
3429:
3430: This routine cleans up all of the memory associated with
3431: any of the devices belonging to the driver. It will
3432: loop through the device list.
3433:
3434: Arguments:
3435:
3436: DriverObject - Pointer to the driver object controling all of the
3437: devices.
3438:
3439: Return Value:
3440:
3441: None.
3442:
3443: --*/
3444:
3445: {
3446:
3447: PDEVICE_OBJECT currentDevice = DriverObject->DeviceObject;
3448:
3449: SerialDump(
3450: SERDIAG3,
3451: ("SERIAL: In SerialUnload\n")
3452: );
3453:
3454: while (currentDevice) {
3455:
3456: PSERIAL_DEVICE_EXTENSION extension = currentDevice->DeviceExtension;
3457:
3458: //
3459: // Look for a device that actually has an isr.
3460: // if we find one then that is a "root" controller.
3461: //
3462:
3463: if (extension->OurIsr) {
3464:
3465: SerialDump(
3466: SERDIAG5,
3467: ("SERIAL: About to do a propagate delete on\n"
3468: "------- extension: %x for port %wZ\n",
3469: extension,&extension->DeviceName)
3470: );
3471: SerialPropagateDeleteSharers(
3472: extension,
3473: &IoGetConfigurationInformation()->SerialCount,
3474: NULL
3475: );
3476:
3477: currentDevice = DriverObject->DeviceObject;
3478:
3479: } else {
3480:
3481: currentDevice = currentDevice->NextDevice;
3482:
3483: }
3484:
3485: }
3486:
3487: }
3488:
3489: VOID
3490: SerialCleanupDevice(
3491: IN PSERIAL_DEVICE_EXTENSION Extension
3492: )
3493:
3494: /*++
3495:
3496: Routine Description:
3497:
3498: This routine will deallocate all of the memory used for
3499: a particular device. It will also disconnect any resources
3500: if need be.
3501:
3502: Arguments:
3503:
3504: Extension - Pointer to the device extension which is getting
3505: rid of all it's resources.
3506:
3507: Return Value:
3508:
3509: None.
3510:
3511: --*/
3512:
3513: {
3514:
3515: SerialDump(
3516: SERDIAG3,
3517: ("SERIAL: in SerialCleanup for extension: %x\n",Extension)
3518: );
3519:
3520: if (Extension) {
3521:
3522: //
3523: // Disconnect the interrupt object first so that some spurious
3524: // interrupt doesn't cause us to dereference some memory we've
3525: // already given up.
3526: //
3527:
3528: if (Extension->Interrupt) {
3529:
3530: SerialDump(
3531: SERDIAG5,
3532: ("SERIAL: Extension has interrupt %x\n",Extension)
3533: );
3534: IoDisconnectInterrupt(Extension->Interrupt);
3535:
3536: }
3537:
3538: KeCancelTimer(&Extension->ReadRequestTotalTimer);
3539: KeCancelTimer(&Extension->ReadRequestIntervalTimer);
3540: KeCancelTimer(&Extension->WriteRequestTotalTimer);
3541: KeCancelTimer(&Extension->ImmediateTotalTimer);
3542: KeCancelTimer(&Extension->XoffCountTimer);
3543: KeCancelTimer(&Extension->LowerRTSTimer);
3544: KeRemoveQueueDpc(&Extension->CompleteWriteDpc);
3545: KeRemoveQueueDpc(&Extension->CompleteReadDpc);
3546: KeRemoveQueueDpc(&Extension->TotalReadTimeoutDpc);
3547: KeRemoveQueueDpc(&Extension->IntervalReadTimeoutDpc);
3548: KeRemoveQueueDpc(&Extension->TotalWriteTimeoutDpc);
3549: KeRemoveQueueDpc(&Extension->CommErrorDpc);
3550: KeRemoveQueueDpc(&Extension->CompleteImmediateDpc);
3551: KeRemoveQueueDpc(&Extension->TotalImmediateTimeoutDpc);
3552: KeRemoveQueueDpc(&Extension->CommWaitDpc);
3553: KeRemoveQueueDpc(&Extension->XoffCountTimeoutDpc);
3554: KeRemoveQueueDpc(&Extension->XoffCountCompleteDpc);
3555: KeRemoveQueueDpc(&Extension->StartTimerLowerRTSDpc);
3556: KeRemoveQueueDpc(&Extension->PerhapsLowerRTSDpc);
3557:
3558: //
3559: // Get rid of all external naming as well as removing
3560: // the device map entry.
3561: //
3562:
3563: SerialCleanupExternalNaming(Extension);
3564:
3565: //
3566: // Delallocate the memory for the various names.
3567: // NOTE: If we have an extension - Then we must
3568: // have a device name stored away. Which is *not*
3569: // true for the other names.
3570: //
3571:
3572: ExFreePool(Extension->DeviceName.Buffer);
3573:
3574: if (Extension->ObjectDirectory.Buffer) {
3575:
3576: ExFreePool(Extension->ObjectDirectory.Buffer);
3577:
3578: }
3579:
3580: if (Extension->NtNameForPort.Buffer) {
3581:
3582: ExFreePool(Extension->NtNameForPort.Buffer);
3583:
3584: }
3585:
3586: if (Extension->SymbolicLinkName.Buffer) {
3587:
3588: ExFreePool(Extension->SymbolicLinkName.Buffer);
3589:
3590: }
3591:
3592: //
3593: // If necessary, unmap the device registers.
3594: //
3595:
3596: if (Extension->UnMapRegisters) {
3597:
3598: MmUnmapIoSpace(
3599: Extension->Controller,
3600: Extension->SpanOfController
3601: );
3602:
3603: }
3604:
3605: if (Extension->UnMapStatus) {
3606:
3607: MmUnmapIoSpace(
3608: Extension->InterruptStatus,
3609: Extension->SpanOfInterruptStatus
3610: );
3611:
3612: }
3613:
3614: }
3615:
3616: }
3617:
3618: NTSTATUS
3619: SerialItemCallBack(
3620: IN PVOID Context,
3621: IN PUNICODE_STRING PathName,
3622: IN INTERFACE_TYPE BusType,
3623: IN ULONG BusNumber,
3624: IN PKEY_VALUE_FULL_INFORMATION *BusInformation,
3625: IN CONFIGURATION_TYPE ControllerType,
3626: IN ULONG ControllerNumber,
3627: IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation,
3628: IN CONFIGURATION_TYPE PeripheralType,
3629: IN ULONG PeripheralNumber,
3630: IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation
3631: )
3632:
3633: /*++
3634:
3635: Routine Description:
3636:
3637: This routine is called to check if a particular item
3638: is present in the registry.
3639:
3640: Arguments:
3641:
3642: Context - Pointer to a boolean.
3643:
3644: PathName - unicode registry path. Not Used.
3645:
3646: BusType - Internal, Isa, ...
3647:
3648: BusNumber - Which bus if we are on a multibus system.
3649:
3650: BusInformation - Configuration information about the bus. Not Used.
3651:
3652: ControllerType - Controller type.
3653:
3654: ControllerNumber - Which controller if there is more than one
3655: controller in the system.
3656:
3657: ControllerInformation - Array of pointers to the three pieces of
3658: registry information.
3659:
3660: PeripheralType - Should be a peripheral.
3661:
3662: PeripheralNumber - Which peripheral - not used..
3663:
3664: PeripheralInformation - Configuration information. Not Used.
3665:
3666: Return Value:
3667:
3668: STATUS_SUCCESS
3669:
3670: --*/
3671:
3672: {
3673:
3674: *((BOOLEAN *)Context) = TRUE;
3675: return STATUS_SUCCESS;
3676: }
3677:
3678: //
3679: // This structure is only used to communicate between the
3680: // code that queries what the firmware found and the code
3681: // that is calling the quering of the firmware data.
3682: //
3683: typedef struct SERIAL_FIRMWARE_DATA {
3684: PDRIVER_OBJECT DriverObject;
3685: ULONG ControllersFound;
3686: ULONG ForceFifoEnableDefault;
3687: ULONG RxFIFODefault;
3688: UNICODE_STRING Directory;
3689: UNICODE_STRING NtNameSuffix;
3690: UNICODE_STRING DirectorySymbolicName;
3691: LIST_ENTRY ConfigList;
3692: } SERIAL_FIRMWARE_DATA,*PSERIAL_FIRMWARE_DATA;
3693:
3694:
3695: NTSTATUS
3696: SerialConfigCallBack(
3697: IN PVOID Context,
3698: IN PUNICODE_STRING PathName,
3699: IN INTERFACE_TYPE BusType,
3700: IN ULONG BusNumber,
3701: IN PKEY_VALUE_FULL_INFORMATION *BusInformation,
3702: IN CONFIGURATION_TYPE ControllerType,
3703: IN ULONG ControllerNumber,
3704: IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation,
3705: IN CONFIGURATION_TYPE PeripheralType,
3706: IN ULONG PeripheralNumber,
3707: IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation
3708: )
3709:
3710: /*++
3711:
3712: Routine Description:
3713:
3714: This routine is used to acquire all of the configuration
3715: information for each serial controller found by the firmware
3716:
3717: Arguments:
3718:
3719: Context - Pointer to the list head of the list of configuration
3720: records that we are building up.
3721:
3722: PathName - unicode registry path. Not Used.
3723:
3724: BusType - Internal, Isa, ...
3725:
3726: BusNumber - Which bus if we are on a multibus system.
3727:
3728: BusInformation - Configuration information about the bus. Not Used.
3729:
3730: ControllerType - Should always be SerialController.
3731:
3732: ControllerNumber - Which controller if there is more than one
3733: controller in the system.
3734:
3735: ControllerInformation - Array of pointers to the three pieces of
3736: registry information.
3737:
3738: PeripheralType - Undefined for this call.
3739:
3740: PeripheralNumber - Undefined for this call.
3741:
3742: PeripheralInformation - Undefined for this call.
3743:
3744: Return Value:
3745:
3746: STATUS_SUCCESS if everything went ok, or STATUS_INSUFFICIENT_RESOURCES
3747: if it couldn't map the base csr or acquire the device object, or
3748: all of the resource information couldn't be acquired.
3749:
3750: --*/
3751:
3752: {
3753:
3754: //
3755: // So we don't have to typecast the context.
3756: //
3757: PSERIAL_FIRMWARE_DATA config = Context;
3758:
3759: //
3760: // Pointer to the configuration stuff for this controller.
3761: //
3762: PCONFIG_DATA controller;
3763:
3764: //
3765: // We use the following two variables to determine if
3766: // we have a pointer peripheral.
3767: //
3768: CONFIGURATION_TYPE pointer = PointerPeripheral;
3769: BOOLEAN foundPointer = FALSE;
3770:
3771: //
3772: // Two booleans to help us determine that we got enough configuration
3773: // data.
3774: //
3775: BOOLEAN foundPort = FALSE;
3776: BOOLEAN foundInterrupt = FALSE;
3777:
3778: //
3779: // Simple iteration variable.
3780: //
3781: ULONG i;
3782:
3783: PCM_FULL_RESOURCE_DESCRIPTOR controllerData;
3784:
3785: ASSERT(ControllerType == SerialController);
3786:
3787: config->ControllersFound++;
3788:
3789: //
3790: // Bail out if some fool wrote a hal and passed me data with no length.
3791: //
3792:
3793: if (!ControllerInformation[IoQueryDeviceConfigurationData]->DataLength) {
3794:
3795: return STATUS_SUCCESS;
3796:
3797: }
3798:
3799: controllerData =
3800: (PCM_FULL_RESOURCE_DESCRIPTOR)
3801: (((PUCHAR)ControllerInformation[IoQueryDeviceConfigurationData]) +
3802: ControllerInformation[IoQueryDeviceConfigurationData]->DataOffset);
3803:
3804: //
3805: // First things first. Call up IoQueryDeviceDescription
3806: // again to see if there is a pointer peripheral. If there
3807: // is then we simply ignore this controller.
3808: //
3809:
3810: IoQueryDeviceDescription(
3811: &BusType,
3812: &BusNumber,
3813: &ControllerType,
3814: &ControllerNumber,
3815: &pointer,
3816: NULL,
3817: SerialItemCallBack,
3818: &foundPointer
3819: );
3820:
3821: if (foundPointer) {
3822:
3823: return STATUS_SUCCESS;
3824:
3825: }
3826:
3827: //
3828: // Allocate the memory for the controller config data out of paged pool
3829: // since we will only be accessing it at initialization time.
3830: //
3831:
3832: controller = ExAllocatePool(
3833: PagedPool,
3834: sizeof(CONFIG_DATA)
3835: );
3836:
3837: if (!controller) {
3838:
3839: SerialLogError(
3840: config->DriverObject,
3841: NULL,
3842: SerialPhysicalZero,
3843: SerialPhysicalZero,
3844: 0,
3845: 0,
3846: 0,
3847: 16,
3848: STATUS_SUCCESS,
3849: SERIAL_INSUFFICIENT_RESOURCES,
3850: 0,
3851: NULL,
3852: 0,
3853: NULL
3854: );
3855: SerialDump(
3856: SERERRORS,
3857: ("SERIAL: Couldn't allocate memory for the configuration data\n"
3858: "------ for firmware data\n")
3859: );
3860: return STATUS_INSUFFICIENT_RESOURCES;
3861:
3862: }
3863:
3864: RtlZeroMemory(
3865: controller,
3866: sizeof(CONFIG_DATA)
3867: );
3868: InitializeListHead(&controller->ConfigList);
3869: InitializeListHead(&controller->SameInterrupt);
3870: InitializeListHead(&controller->SameInterruptStatus);
3871:
3872: controller->InterfaceType = BusType;
3873: controller->BusNumber = BusNumber;
3874:
3875: //
3876: // Stick in the default fifo enable an rx trigger for the firmware
3877: // found comm ports.
3878: //
3879:
3880: controller->ForceFifoEnable = config->ForceFifoEnableDefault;
3881: controller->RxFIFO = config->RxFIFODefault;
3882:
3883: //
3884: // We need to get the following information out of the partial
3885: // resource descriptors.
3886: //
3887: // The irql and vector.
3888: //
3889: // The base address and span covered by the serial controllers
3890: // registers.
3891: //
3892: // It is not defined how these appear in the partial resource
3893: // lists, so we will just loop over all of them. If we find
3894: // something we don't recognize, we drop that information on
3895: // the floor. When we have finished going through all the
3896: // partial information, we validate that we got the above
3897: // two.
3898: //
3899: // The other additional piece of data that we seek is the
3900: // baud rate input clock speed. Unless it is specified
3901: // in the device specific portion of the resource list we
3902: // will default it to 1.8432Mhz.
3903: //
3904:
3905: controller->ClockRate = 1843200;
3906: for (
3907: i = 0;
3908: i < controllerData->PartialResourceList.Count;
3909: i++
3910: ) {
3911:
3912: PCM_PARTIAL_RESOURCE_DESCRIPTOR partial =
3913: &controllerData->PartialResourceList.PartialDescriptors[i];
3914:
3915: switch (partial->Type) {
3916:
3917: case CmResourceTypePort: {
3918:
3919: foundPort = TRUE;
3920:
3921: //
3922: // No matter what the registry says, we
3923: // know how long the register set is.
3924: //
3925:
3926: controller->SpanOfController = SERIAL_REGISTER_SPAN;
3927: controller->Controller = partial->u.Port.Start;
3928: controller->AddressSpace = partial->Flags;
3929:
3930: break;
3931: }
3932: case CmResourceTypeInterrupt: {
3933:
3934: foundInterrupt = TRUE;
3935: if (partial->Flags & CM_RESOURCE_INTERRUPT_LATCHED) {
3936:
3937: controller->InterruptMode = Latched;
3938:
3939: } else {
3940:
3941: controller->InterruptMode = LevelSensitive;
3942:
3943: }
3944:
3945: controller->OriginalIrql = partial->u.Interrupt.Level;
3946: controller->OriginalVector = partial->u.Interrupt.Vector;
3947:
3948: break;
3949:
3950: }
3951: case CmResourceTypeDeviceSpecific: {
3952:
3953: PCM_SERIAL_DEVICE_DATA sDeviceData;
3954:
3955: sDeviceData = (PCM_SERIAL_DEVICE_DATA)(partial + 1);
3956:
3957: controller->ClockRate = sDeviceData->BaudClock;
3958:
3959: break;
3960:
3961: }
3962: default: {
3963:
3964: break;
3965:
3966: }
3967:
3968: }
3969:
3970: }
3971:
3972: if (foundPort && foundInterrupt) {
3973:
3974: WCHAR ntNumberBuffer[100];
3975: WCHAR symbolicNumberBuffer[100];
3976: UNICODE_STRING ntNumberString;
3977: UNICODE_STRING symbolicNumberString;
3978:
3979: ntNumberString.Length = 0;
3980: ntNumberString.MaximumLength = 100;
3981: ntNumberString.Buffer = &ntNumberBuffer[0];
3982:
3983: symbolicNumberString.Length = 0;
3984: symbolicNumberString.MaximumLength = 100;
3985: symbolicNumberString.Buffer = &symbolicNumberBuffer[0];
3986:
3987: //
3988: // Everthing is great so far. We now need to form the
3989: // Nt Names and symbolic link names.
3990: //
3991:
3992: if (!NT_SUCCESS(RtlIntegerToUnicodeString(
3993: config->ControllersFound - 1,
3994: 10,
3995: &ntNumberString
3996: ))) {
3997:
3998: SerialLogError(
3999: config->DriverObject,
4000: NULL,
4001: controller->Controller,
4002: SerialPhysicalZero,
4003: 0,
4004: 0,
4005: 0,
4006: 17,
4007: STATUS_SUCCESS,
4008: SERIAL_INSUFFICIENT_RESOURCES,
4009: 0,
4010: NULL,
4011: 0,
4012: NULL
4013: );
4014: SerialDump(
4015: SERERRORS,
4016: ("SERIAL: Couldn't convert NT controller number to\n"
4017: "------ to unicode for firmware data: %d\n",
4018: config->ControllersFound - 1)
4019: );
4020: //
4021: // Oh well, ignore this controller.
4022: //
4023: ExFreePool(controller);
4024:
4025: } else {
4026:
4027: if (!NT_SUCCESS(RtlIntegerToUnicodeString(
4028: config->ControllersFound,
4029: 10,
4030: &symbolicNumberString
4031: ))) {
4032:
4033: SerialLogError(
4034: config->DriverObject,
4035: NULL,
4036: controller->Controller,
4037: SerialPhysicalZero,
4038: 0,
4039: 0,
4040: 0,
4041: 18,
4042: STATUS_SUCCESS,
4043: SERIAL_INSUFFICIENT_RESOURCES,
4044: 0,
4045: NULL,
4046: 0,
4047: NULL
4048: );
4049: SerialDump(
4050: SERERRORS,
4051: ("SERIAL: Couldn't allocate convert symbolic controller number to\n"
4052: "------ to unicode for firmware data: %d\n",
4053: config->ControllersFound)
4054: );
4055: ExFreePool(controller);
4056:
4057: } else {
4058:
4059: UNICODE_STRING Temp;
4060:
4061: //
4062: // Ok, we have the non-constant portions of the
4063: // names all figured out. Now allocate memory
4064: // for what will be used later.
4065: //
4066:
4067: //
4068: // Save off a copy of the object directory name.
4069: //
4070:
4071: //
4072: // Init the destination.
4073: //
4074: RtlInitUnicodeString(
4075: &controller->ObjectDirectory,
4076: NULL
4077: );
4078:
4079: //
4080: // This will get its length.
4081: //
4082: RtlInitUnicodeString(
4083: &Temp,
4084: DEFAULT_DIRECTORY
4085: );
4086:
4087: //
4088: // Now allocate that much.
4089: //
4090:
4091: controller->ObjectDirectory.Buffer =
4092: ExAllocatePool(
4093: PagedPool,
4094: Temp.Length+sizeof(WCHAR)
4095: );
4096:
4097: if (!controller->ObjectDirectory.Buffer) {
4098:
4099: SerialLogError(
4100: config->DriverObject,
4101: NULL,
4102: controller->Controller,
4103: SerialPhysicalZero,
4104: 0,
4105: 0,
4106: 0,
4107: 19,
4108: STATUS_SUCCESS,
4109: SERIAL_INSUFFICIENT_RESOURCES,
4110: 0,
4111: NULL,
4112: 0,
4113: NULL
4114: );
4115: SerialDump(
4116: SERERRORS,
4117: ("SERIAL: Couldn't allocate memory for object\n"
4118: "------ directory for NT firmware data: %d\n",
4119: config->ControllersFound - 1)
4120: );
4121: ExFreePool(controller);
4122: return STATUS_SUCCESS;
4123:
4124: } else {
4125:
4126: controller->ObjectDirectory.MaximumLength =
4127: Temp.Length+sizeof(WCHAR);
4128:
4129: //
4130: // Zero fill it.
4131: //
4132:
4133: RtlZeroMemory(
4134: controller->ObjectDirectory.Buffer,
4135: controller->ObjectDirectory.MaximumLength
4136: );
4137:
4138: RtlAppendUnicodeStringToString(
4139: &controller->ObjectDirectory,
4140: &Temp
4141: );
4142:
4143: }
4144:
4145: //
4146: // Init the destination.
4147: //
4148: RtlInitUnicodeString(
4149: &controller->NtNameForPort,
4150: NULL
4151: );
4152:
4153: //
4154: // This will get its length.
4155: //
4156: RtlInitUnicodeString(
4157: &Temp,
4158: DEFAULT_NT_SUFFIX
4159: );
4160:
4161: //
4162: // Allocate enough for the suffix and the number.
4163: //
4164:
4165: controller->NtNameForPort.Buffer =
4166: ExAllocatePool(
4167: PagedPool,
4168: Temp.Length +
4169: ntNumberString.Length + sizeof(WCHAR)
4170: );
4171:
4172: if (!controller->NtNameForPort.Buffer) {
4173:
4174: SerialLogError(
4175: config->DriverObject,
4176: NULL,
4177: controller->Controller,
4178: SerialPhysicalZero,
4179: 0,
4180: 0,
4181: 0,
4182: 20,
4183: STATUS_SUCCESS,
4184: SERIAL_INSUFFICIENT_RESOURCES,
4185: 0,
4186: NULL,
4187: 0,
4188: NULL
4189: );
4190: SerialDump(
4191: SERERRORS,
4192: ("SERIAL: Couldn't allocate memory for NT\n"
4193: "------ name for NT firmware data: %d\n",
4194: config->ControllersFound - 1)
4195: );
4196: ExFreePool(controller->ObjectDirectory.Buffer);
4197: ExFreePool(controller);
4198: return STATUS_SUCCESS;
4199:
4200: } else {
4201:
4202: controller->NtNameForPort.MaximumLength =
4203: Temp.Length+ntNumberString.Length+sizeof(WCHAR);
4204:
4205: RtlZeroMemory(
4206: controller->NtNameForPort.Buffer,
4207: controller->NtNameForPort.MaximumLength
4208: );
4209:
4210: RtlAppendUnicodeStringToString(
4211: &controller->NtNameForPort,
4212: &Temp
4213: );
4214:
4215: RtlAppendUnicodeStringToString(
4216: &controller->NtNameForPort,
4217: &ntNumberString
4218: );
4219:
4220: }
4221:
4222: //
4223: // Now form that name that will be used as a
4224: // symbolic link to the actual device name
4225: // we just formed.
4226: //
4227:
4228: RtlInitUnicodeString(
4229: &controller->SymbolicLinkName,
4230: NULL
4231: );
4232:
4233: //
4234: // This will get its length.
4235: //
4236: RtlInitUnicodeString(
4237: &Temp,
4238: DEFAULT_SERIAL_NAME
4239: );
4240:
4241: //
4242: // Allocate enough for the suffix and the number.
4243: //
4244:
4245: controller->SymbolicLinkName.Buffer =
4246: ExAllocatePool(
4247: PagedPool,
4248: Temp.Length +
4249: symbolicNumberString.Length+sizeof(WCHAR)
4250: );
4251:
4252: if (!controller->SymbolicLinkName.Buffer) {
4253:
4254: SerialLogError(
4255: config->DriverObject,
4256: NULL,
4257: controller->Controller,
4258: SerialPhysicalZero,
4259: 0,
4260: 0,
4261: 0,
4262: 21,
4263: STATUS_SUCCESS,
4264: SERIAL_INSUFFICIENT_RESOURCES,
4265: 0,
4266: NULL,
4267: 0,
4268: NULL
4269: );
4270: SerialDump(
4271: SERERRORS,
4272: ("SERIAL: Couldn't allocate memory for symbolic\n"
4273: "------ name for NT firmware data: %d\n",
4274: config->ControllersFound - 1)
4275: );
4276: ExFreePool(controller->ObjectDirectory.Buffer);
4277: ExFreePool(controller->NtNameForPort.Buffer);
4278: ExFreePool(controller);
4279: return STATUS_SUCCESS;
4280:
4281: } else {
4282:
4283: controller->SymbolicLinkName.MaximumLength =
4284: Temp.Length+symbolicNumberString.Length+sizeof(WCHAR);
4285:
4286: RtlZeroMemory(
4287: controller->SymbolicLinkName.Buffer,
4288: controller->SymbolicLinkName.MaximumLength
4289: );
4290:
4291: RtlAppendUnicodeStringToString(
4292: &controller->SymbolicLinkName,
4293: &Temp
4294: );
4295:
4296: RtlAppendUnicodeStringToString(
4297: &controller->SymbolicLinkName,
4298: &symbolicNumberString
4299: );
4300:
4301: }
4302:
4303: InsertTailList(
4304: &config->ConfigList,
4305: &controller->ConfigList
4306: );
4307:
4308: }
4309:
4310: }
4311:
4312: } else {
4313:
4314: SerialLogError(
4315: config->DriverObject,
4316: NULL,
4317: controller->Controller,
4318: SerialPhysicalZero,
4319: 0,
4320: 0,
4321: 0,
4322: 22,
4323: STATUS_SUCCESS,
4324: SERIAL_NOT_ENOUGH_CONFIG_INFO,
4325: 0,
4326: NULL,
4327: 0,
4328: NULL
4329: );
4330: ExFreePool(controller);
4331:
4332: }
4333:
4334: return STATUS_SUCCESS;
4335: }
4336:
4337: VOID
4338: SerialGetConfigInfo(
4339: IN PDRIVER_OBJECT DriverObject,
4340: IN PUNICODE_STRING RegistryPath,
4341: ULONG ForceFifoEnableDefault,
4342: ULONG RxFIFODefault,
4343: OUT PLIST_ENTRY ConfigList
4344: )
4345:
4346: /*++
4347:
4348: Routine Description:
4349:
4350: This routine will "return" a list of configuration
4351: records for the serial ports to initialize.
4352:
4353: It will first query the firmware data. It will then
4354: look for "user" specified comm ports in the registry.
4355: It will place the user specified comm ports in the
4356: the passed in list.
4357:
4358: After it finds all of the user specified port, it will
4359: attempt to add the firmware comm ports into the passed
4360: in lists. The insert in the list code detects conflicts
4361: and rejects a new comm port. In this way we can prevent
4362: firmware found comm ports from overiding information
4363: specified by the "user". Note, this means if the user
4364: specified data is incorrect in its use of the interrupt
4365: (which should *always* be correct from the firmware)
4366: that port likely will not work. But, then, we "trust"
4367: the user.
4368:
4369:
4370: Arguments:
4371:
4372: DriverObject - Not used.
4373:
4374: RegistryPath - Path to this drivers service node in
4375: the current control set.
4376:
4377: ForceFifoEnableDefault - Gotten from the services node.
4378:
4379: RxFifoDefault - Gotten from the services node.
4380:
4381: ConfigList - Listhead (which will be intialized) for a list
4382: of configuration records for ports to control.
4383:
4384: Return Value:
4385:
4386: STATUS_SUCCESS if consistant configuration was found - otherwise.
4387: returns STATUS_SERIAL_NO_DEVICE_INITED.
4388:
4389: --*/
4390:
4391: {
4392:
4393: SERIAL_FIRMWARE_DATA firmware;
4394:
4395: PRTL_QUERY_REGISTRY_TABLE parameters = NULL;
4396:
4397: INTERFACE_TYPE interfaceType;
4398: ULONG defaultInterfaceType;
4399:
4400:
4401: //
4402: // Default values for user data.
4403: //
4404: ULONG maxUlong = MAXULONG;
4405: ULONG zero = 0;
4406: ULONG clockRate = 1843200;
4407: ULONG defaultInterruptMode;
4408: ULONG defaultAddressSpace = CM_RESOURCE_PORT_IO;
4409:
4410: //
4411: // Where user data from the registry will be placed.
4412: //
4413:
4414: PHYSICAL_ADDRESS userPort;
4415: ULONG userVector;
4416: ULONG userLevel;
4417: PHYSICAL_ADDRESS userInterruptStatus;
4418: ULONG userPortIndex;
4419: ULONG userBusNumber;
4420: ULONG userInterfaceType;
4421: ULONG userClockRate;
4422: ULONG userIndexed;
4423: ULONG userAddressSpace;
4424: ULONG userInterruptMode;
4425: ULONG firmwareFound;
4426: ULONG disablePort;
4427: ULONG forceFifoEnable;
4428: ULONG rxFIFO;
4429: UNICODE_STRING userSymbolicLink;
4430:
4431: UNICODE_STRING parametersPath;
4432: OBJECT_ATTRIBUTES parametersAttributes;
4433: HANDLE parametersKey;
4434: PKEY_BASIC_INFORMATION userSubKey = NULL;
4435: ULONG i;
4436:
4437:
4438: RTL_QUERY_REGISTRY_TABLE jensenTable[2] = {0};
4439: UNICODE_STRING jensenData;
4440: UNICODE_STRING jensenValue;
4441: BOOLEAN jensenDetected;
4442: PUCHAR jensenBuffer;
4443:
4444:
4445: if (!(jensenBuffer = ExAllocatePool(
4446: PagedPool,
4447: 512
4448: ))) {
4449:
4450: //
4451: // We couldn't allocate 512 bytes of paged pool. If that's
4452: // so, then it's likely that the least of this machines problem's
4453: // is that it's a Jensen.
4454: //
4455:
4456: jensenDetected = FALSE;
4457:
4458: } else {
4459:
4460: //
4461: // Check to see if this is a Jensen alpha. If we do, then
4462: // well have to change the way we enable and disable interrupts
4463: //
4464:
4465: jensenData.Length = 0;
4466: jensenData.MaximumLength = 512;
4467: jensenData.Buffer = (PWCHAR)&jensenBuffer[0];
4468: RtlInitUnicodeString(
4469: &jensenValue,
4470: L"Jensen"
4471: );
4472: jensenTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT |
4473: RTL_QUERY_REGISTRY_REQUIRED;
4474: jensenTable[0].Name = L"Identifier";
4475: jensenTable[0].EntryContext = &jensenData;
4476:
4477: if (!NT_SUCCESS(RtlQueryRegistryValues(
4478: RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
4479: L"\\REGISTRY\\MACHINE\\HARDWARE\\DESCRIPTION\\SYSTEM",
4480: &jensenTable[0],
4481: NULL,
4482: NULL
4483: ))) {
4484:
4485: //
4486: // How odd, no identifer string! We'll it's probably not a jensen.
4487: //
4488:
4489: jensenDetected = FALSE;
4490:
4491: } else {
4492:
4493: //
4494: // Skip past the DEC-XX Portion of the name string.
4495: // Be carful and make sure we have at least that much data.
4496: //
4497:
4498: if (jensenData.Length <= (sizeof(WCHAR)*6)) {
4499:
4500: jensenDetected = FALSE;
4501:
4502: } else {
4503:
4504: jensenData.Length -= (sizeof(WCHAR)*6);
4505: jensenData.MaximumLength -= (sizeof(WCHAR)*6);
4506: jensenData.Buffer = (PWCHAR)&jensenBuffer[sizeof(WCHAR)*6];
4507: jensenDetected = RtlEqualUnicodeString(
4508: &jensenData,
4509: &jensenValue,
4510: FALSE
4511: );
4512:
4513: }
4514:
4515: }
4516:
4517: ExFreePool(jensenBuffer);
4518:
4519: }
4520:
4521: if (jensenDetected) {
4522:
4523: SerialDump(
4524: SERDIAG1,
4525: ("SERIAL: Jensen Detected\n")
4526: );
4527:
4528: }
4529:
4530: InitializeListHead(ConfigList);
4531:
4532: RtlZeroMemory(
4533: &firmware,
4534: sizeof(SERIAL_FIRMWARE_DATA)
4535: );
4536:
4537: firmware.DriverObject = DriverObject;
4538: firmware.ForceFifoEnableDefault = ForceFifoEnableDefault;
4539: firmware.RxFIFODefault = RxFIFODefault;
4540: InitializeListHead(&firmware.ConfigList);
4541: RtlInitUnicodeString(
4542: &firmware.Directory,
4543: DEFAULT_DIRECTORY
4544: );
4545: RtlInitUnicodeString(
4546: &firmware.NtNameSuffix,
4547: DEFAULT_NT_SUFFIX
4548: );
4549: RtlInitUnicodeString(
4550: &firmware.DirectorySymbolicName,
4551: DEFAULT_SERIAL_NAME
4552: );
4553:
4554: //
4555: // First we query the hardware registry for all of
4556: // the firmware defined serial ports. We loop over
4557: // all of the busses.
4558: //
4559:
4560: for (
4561: interfaceType = 0;
4562: interfaceType < MaximumInterfaceType;
4563: interfaceType++
4564: ) {
4565:
4566: CONFIGURATION_TYPE sc = SerialController;
4567:
4568: IoQueryDeviceDescription(
4569: &interfaceType,
4570: NULL,
4571: &sc,
4572: NULL,
4573: NULL,
4574: NULL,
4575: SerialConfigCallBack,
4576: &firmware
4577: );
4578:
4579: }
4580:
4581: //
4582: // Query the registry one more time. This time we
4583: // look for the first bus on the system (that isn't
4584: // the internal bus - we assume that the firmware
4585: // code knows about those ports). We will use that
4586: // as the default bus if no bustype or bus number
4587: // is specified in the "user" configuration records.
4588: //
4589:
4590: defaultInterfaceType = (ULONG)Isa;
4591: defaultInterruptMode = CM_RESOURCE_INTERRUPT_LATCHED;
4592:
4593: for (
4594: interfaceType = 0;
4595: interfaceType < MaximumInterfaceType;
4596: interfaceType++
4597: ) {
4598:
4599: ULONG busZero = 0;
4600: BOOLEAN foundOne = FALSE;
4601:
4602: if (interfaceType != Internal) {
4603:
4604: IoQueryDeviceDescription(
4605: &interfaceType,
4606: &busZero,
4607: NULL,
4608: NULL,
4609: NULL,
4610: NULL,
4611: SerialItemCallBack,
4612: &foundOne
4613: );
4614:
4615: if (foundOne) {
4616:
4617: defaultInterfaceType = (ULONG)interfaceType;
4618: if (defaultInterfaceType == MicroChannel) {
4619:
4620: defaultInterruptMode = CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE;
4621:
4622: }
4623:
4624: break;
4625:
4626: }
4627:
4628: }
4629:
4630: }
4631:
4632: //
4633: // Gonna get the user data now. Allocate the
4634: // structures that we will be using throughout
4635: // the search for user data. We will deallocate
4636: // them before we leave this routine.
4637: //
4638:
4639: userSymbolicLink.Buffer = NULL;
4640: parametersPath.Buffer = NULL;
4641:
4642: //
4643: // Allocate the rtl query table. This should have an entry for each value
4644: // we retrieve from the registry as well as a terminating zero entry as
4645: // well the first "goto subkey" entry.
4646: //
4647:
4648: parameters = ExAllocatePool(
4649: PagedPool,
4650: sizeof(RTL_QUERY_REGISTRY_TABLE)*18
4651: );
4652:
4653: if (!parameters) {
4654:
4655: SerialLogError(
4656: DriverObject,
4657: NULL,
4658: SerialPhysicalZero,
4659: SerialPhysicalZero,
4660: 0,
4661: 0,
4662: 0,
4663: 23,
4664: STATUS_SUCCESS,
4665: SERIAL_INSUFFICIENT_RESOURCES,
4666: 0,
4667: NULL,
4668: 0,
4669: NULL
4670: );
4671: SerialDump(
4672: SERERRORS,
4673: ("SERIAL: Couldn't allocate table for rtl query\n"
4674: "------ to parameters for %wZ",
4675: RegistryPath)
4676: );
4677:
4678: goto DoFirmwareAdd;
4679:
4680: }
4681:
4682: RtlZeroMemory(
4683: parameters,
4684: sizeof(RTL_QUERY_REGISTRY_TABLE)*18
4685: );
4686:
4687: //
4688: // Allocate the place where the users symbolic link name
4689: // for the port will go.
4690: //
4691:
4692: //
4693: // We will initially allocate space for 257 wchars.
4694: // we will then set the maximum size to 256
4695: // This way the rtl routine could return a 256
4696: // WCHAR wide string with no null terminator.
4697: // We'll remember that the buffer is one WCHAR
4698: // longer then it says it is so that we can always
4699: // have a NULL terminator at the end.
4700: //
4701:
4702: RtlInitUnicodeString(
4703: &userSymbolicLink,
4704: NULL
4705: );
4706: userSymbolicLink.MaximumLength = sizeof(WCHAR)*256;
4707: userSymbolicLink.Buffer = ExAllocatePool(
4708: PagedPool,
4709: sizeof(WCHAR)*257
4710: );
4711:
4712: if (!userSymbolicLink.Buffer) {
4713:
4714: SerialLogError(
4715: DriverObject,
4716: NULL,
4717: SerialPhysicalZero,
4718: SerialPhysicalZero,
4719: 0,
4720: 0,
4721: 0,
4722: 24,
4723: STATUS_SUCCESS,
4724: SERIAL_INSUFFICIENT_RESOURCES,
4725: 0,
4726: NULL,
4727: 0,
4728: NULL
4729: );
4730: SerialDump(
4731: SERERRORS,
4732: ("SERIAL: Couldn't allocate buffer for the symbolic link\n"
4733: "------ for parameters items in %wZ",
4734: RegistryPath)
4735: );
4736:
4737: goto DoFirmwareAdd;
4738:
4739: }
4740:
4741: //
4742: // Form a path to our drivers Parameters subkey.
4743: //
4744:
4745: RtlInitUnicodeString(
4746: ¶metersPath,
4747: NULL
4748: );
4749:
4750: parametersPath.MaximumLength = RegistryPath->Length +
4751: sizeof(L"\\") +
4752: sizeof(L"Parameters");
4753:
4754: parametersPath.Buffer = ExAllocatePool(
4755: PagedPool,
4756: parametersPath.MaximumLength
4757: );
4758:
4759: if (!parametersPath.Buffer) {
4760:
4761: SerialLogError(
4762: DriverObject,
4763: NULL,
4764: SerialPhysicalZero,
4765: SerialPhysicalZero,
4766: 0,
4767: 0,
4768: 0,
4769: 25,
4770: STATUS_SUCCESS,
4771: SERIAL_INSUFFICIENT_RESOURCES,
4772: 0,
4773: NULL,
4774: 0,
4775: NULL
4776: );
4777: SerialDump(
4778: SERERRORS,
4779: ("SERIAL: Couldn't allocate string for path\n"
4780: "------ to parameters for %wZ",
4781: RegistryPath)
4782: );
4783:
4784: goto DoFirmwareAdd;
4785:
4786: }
4787:
4788: //
4789: // Form the parameters path.
4790: //
4791:
4792: RtlZeroMemory(
4793: parametersPath.Buffer,
4794: parametersPath.MaximumLength
4795: );
4796: RtlAppendUnicodeStringToString(
4797: ¶metersPath,
4798: RegistryPath
4799: );
4800: RtlAppendUnicodeToString(
4801: ¶metersPath,
4802: L"\\"
4803: );
4804: RtlAppendUnicodeToString(
4805: ¶metersPath,
4806: L"Parameters"
4807: );
4808:
4809: userSubKey = ExAllocatePool(
4810: PagedPool,
4811: sizeof(KEY_BASIC_INFORMATION)+(sizeof(WCHAR)*256)
4812: );
4813:
4814: if (!userSubKey) {
4815:
4816: SerialLogError(
4817: DriverObject,
4818: NULL,
4819: SerialPhysicalZero,
4820: SerialPhysicalZero,
4821: 0,
4822: 0,
4823: 0,
4824: 26,
4825: STATUS_SUCCESS,
4826: SERIAL_INSUFFICIENT_RESOURCES,
4827: 0,
4828: NULL,
4829: 0,
4830: NULL
4831: );
4832: SerialDump(
4833: SERERRORS,
4834: ("SERIAL: Couldn't allocate memory basic information\n"
4835: "------ structure to enumerate subkeys for %wZ",
4836: ¶metersPath)
4837: );
4838:
4839: goto DoFirmwareAdd;
4840:
4841: }
4842:
4843: //
4844: // Open the key given by our registry path & Parameters.
4845: //
4846:
4847: InitializeObjectAttributes(
4848: ¶metersAttributes,
4849: ¶metersPath,
4850: OBJ_CASE_INSENSITIVE,
4851: NULL,
4852: NULL
4853: );
4854:
4855: if (!NT_SUCCESS(ZwOpenKey(
4856: ¶metersKey,
4857: MAXIMUM_ALLOWED,
4858: ¶metersAttributes
4859: ))) {
4860:
4861: SerialLogError(
4862: DriverObject,
4863: NULL,
4864: SerialPhysicalZero,
4865: SerialPhysicalZero,
4866: 0,
4867: 0,
4868: 0,
4869: 27,
4870: STATUS_SUCCESS,
4871: SERIAL_NO_PARAMETERS_INFO,
4872: 0,
4873: NULL,
4874: 0,
4875: NULL
4876: );
4877: SerialDump(
4878: SERERRORS,
4879: ("SERIAL: Couldn't open the drivers Parameters key %wZ\n",
4880: RegistryPath)
4881: );
4882: goto DoFirmwareAdd;
4883:
4884: }
4885:
4886: //
4887: // Gather all of the "user specified" information from
4888: // the registry.
4889: //
4890:
4891: parameters[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
4892:
4893: parameters[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
4894: parameters[1].Name = L"PortAddress";
4895: parameters[1].EntryContext = &userPort.LowPart;
4896: parameters[1].DefaultType = REG_DWORD;
4897: parameters[1].DefaultData = &zero;
4898: parameters[1].DefaultLength = sizeof(ULONG);
4899:
4900: parameters[2].Flags = RTL_QUERY_REGISTRY_DIRECT;
4901: parameters[2].Name = L"Interrupt";
4902: parameters[2].EntryContext = &userVector;
4903: parameters[2].DefaultType = REG_DWORD;
4904: parameters[2].DefaultData = &zero;
4905: parameters[2].DefaultLength = sizeof(ULONG);
4906:
4907: parameters[3].Flags = RTL_QUERY_REGISTRY_DIRECT;
4908: parameters[3].Name = firmware.Directory.Buffer;
4909: parameters[3].EntryContext = &userSymbolicLink;
4910: parameters[3].DefaultType = REG_SZ;
4911: parameters[3].DefaultData = L"";
4912: parameters[3].DefaultLength = 0;
4913:
4914: parameters[4].Flags = RTL_QUERY_REGISTRY_DIRECT;
4915: parameters[4].Name = L"InterruptStatus";
4916: parameters[4].EntryContext = &userInterruptStatus.LowPart;
4917: parameters[4].DefaultType = REG_DWORD;
4918: parameters[4].DefaultData = &zero;
4919: parameters[4].DefaultLength = sizeof(ULONG);
4920:
4921: parameters[5].Flags = RTL_QUERY_REGISTRY_DIRECT;
4922: parameters[5].Name = L"PortIndex";
4923: parameters[5].EntryContext = &userPortIndex;
4924: parameters[5].DefaultType = REG_DWORD;
4925: parameters[5].DefaultData = &zero;
4926: parameters[5].DefaultLength = sizeof(ULONG);
4927:
4928: parameters[6].Flags = RTL_QUERY_REGISTRY_DIRECT;
4929: parameters[6].Name = L"BusNumber";
4930: parameters[6].EntryContext = &userBusNumber;
4931: parameters[6].DefaultType = REG_DWORD;
4932: parameters[6].DefaultData = &zero;
4933: parameters[6].DefaultLength = sizeof(ULONG);
4934:
4935: parameters[7].Flags = RTL_QUERY_REGISTRY_DIRECT;
4936: parameters[7].Name = L"BusType";
4937: parameters[7].EntryContext = &userInterfaceType;
4938: parameters[7].DefaultType = REG_DWORD;
4939: parameters[7].DefaultData = &defaultInterfaceType;
4940: parameters[7].DefaultLength = sizeof(ULONG);
4941:
4942: parameters[8].Flags = RTL_QUERY_REGISTRY_DIRECT;
4943: parameters[8].Name = L"ClockRate";
4944: parameters[8].EntryContext = &userClockRate;
4945: parameters[8].DefaultType = REG_DWORD;
4946: parameters[8].DefaultData = &clockRate;
4947: parameters[8].DefaultLength = sizeof(ULONG);
4948:
4949: parameters[9].Flags = RTL_QUERY_REGISTRY_DIRECT;
4950: parameters[9].Name = L"Indexed";
4951: parameters[9].EntryContext = &userIndexed;
4952: parameters[9].DefaultType = REG_DWORD;
4953: parameters[9].DefaultData = &zero;
4954: parameters[9].DefaultLength = sizeof(ULONG);
4955:
4956: parameters[10].Flags = RTL_QUERY_REGISTRY_DIRECT;
4957: parameters[10].Name = L"InterruptMode";
4958: parameters[10].EntryContext = &userInterruptMode;
4959: parameters[10].DefaultType = REG_DWORD;
4960: parameters[10].DefaultData = &defaultInterruptMode;
4961: parameters[10].DefaultLength = sizeof(ULONG);
4962:
4963: parameters[11].Flags = RTL_QUERY_REGISTRY_DIRECT;
4964: parameters[11].Name = L"AddressSpace";
4965: parameters[11].EntryContext = &userAddressSpace;
4966: parameters[11].DefaultType = REG_DWORD;
4967: parameters[11].DefaultData = &defaultAddressSpace;
4968: parameters[11].DefaultLength = sizeof(ULONG);
4969:
4970: parameters[12].Flags = RTL_QUERY_REGISTRY_DIRECT;
4971: parameters[12].Name = L"InterruptLevel";
4972: parameters[12].EntryContext = &userLevel;
4973: parameters[12].DefaultType = REG_DWORD;
4974: parameters[12].DefaultData = &zero;
4975: parameters[12].DefaultLength = sizeof(ULONG);
4976:
4977: parameters[13].Flags = RTL_QUERY_REGISTRY_DIRECT;
4978: parameters[13].Name = L"FirmwareFound";
4979: parameters[13].EntryContext = &firmwareFound;
4980: parameters[13].DefaultType = REG_DWORD;
4981: parameters[13].DefaultData = &zero;
4982: parameters[13].DefaultLength = sizeof(ULONG);
4983:
4984: parameters[14].Flags = RTL_QUERY_REGISTRY_DIRECT;
4985: parameters[14].Name = L"DisablePort";
4986: parameters[14].EntryContext = &disablePort;
4987: parameters[14].DefaultType = REG_DWORD;
4988: parameters[14].DefaultData = &zero;
4989: parameters[14].DefaultLength = sizeof(ULONG);
4990:
4991: parameters[15].Flags = RTL_QUERY_REGISTRY_DIRECT;
4992: parameters[15].Name = L"ForceFifoEnable";
4993: parameters[15].EntryContext = &forceFifoEnable;
4994: parameters[15].DefaultType = REG_DWORD;
4995: parameters[15].DefaultData = &ForceFifoEnableDefault;
4996: parameters[15].DefaultLength = sizeof(ULONG);
4997:
4998: parameters[16].Flags = RTL_QUERY_REGISTRY_DIRECT;
4999: parameters[16].Name = L"RxFIFO";
5000: parameters[16].EntryContext = &rxFIFO;
5001: parameters[16].DefaultType = REG_DWORD;
5002: parameters[16].DefaultData = &RxFIFODefault;
5003: parameters[16].DefaultLength = sizeof(ULONG);
5004:
5005:
5006:
5007: i = 0;
5008: while (TRUE) {
5009:
5010: NTSTATUS status;
5011: ULONG actuallyReturned;
5012:
5013: //
5014: // We lie about the length of the buffer, so that we can
5015: // MAKE SURE that the name it returns can be padded with
5016: // a NULL.
5017: //
5018:
5019: status = ZwEnumerateKey(
5020: parametersKey,
5021: i,
5022: KeyBasicInformation,
5023: userSubKey,
5024: sizeof(KEY_BASIC_INFORMATION)+(sizeof(WCHAR)*255),
5025: &actuallyReturned
5026: );
5027:
5028: if (status == STATUS_NO_MORE_ENTRIES) {
5029:
5030: break;
5031: }
5032:
5033: if (status == STATUS_BUFFER_OVERFLOW) {
5034:
5035: SerialLogError(
5036: DriverObject,
5037: NULL,
5038: SerialPhysicalZero,
5039: SerialPhysicalZero,
5040: 0,
5041: 0,
5042: 0,
5043: 28,
5044: STATUS_SUCCESS,
5045: SERIAL_UNABLE_TO_ACCESS_CONFIG,
5046: 0,
5047: NULL,
5048: 0,
5049: NULL
5050: );
5051: SerialDump(
5052: SERERRORS,
5053: ("SERIAL: Overflowed the enumerate buffer\n"
5054: "------- for subkey #%d of %wZ\n",
5055: i,parametersPath)
5056: );
5057: i++;
5058: continue;
5059:
5060: }
5061:
5062: if (!NT_SUCCESS(status)) {
5063:
5064: SerialLogError(
5065: DriverObject,
5066: NULL,
5067: SerialPhysicalZero,
5068: SerialPhysicalZero,
5069: 0,
5070: 0,
5071: 0,
5072: 29,
5073: status,
5074: SERIAL_UNABLE_TO_ACCESS_CONFIG,
5075: 0,
5076: NULL,
5077: 0,
5078: NULL
5079: );
5080: SerialDump(
5081: SERERRORS,
5082: ("SERIAL: Bad status returned: %x \n"
5083: "------- on enumeration for subkey # %d of %wZ\n",
5084: status,i,parametersPath)
5085: );
5086: i++;
5087: continue;
5088:
5089: }
5090:
5091: //
5092: // Pad the name returned with a null.
5093: //
5094:
5095: RtlZeroMemory(
5096: ((PUCHAR)(&userSubKey->Name[0]))+userSubKey->NameLength,
5097: sizeof(WCHAR)
5098: );
5099:
5100: parameters[0].Name = &userSubKey->Name[0];
5101:
5102: //
5103: // Make sure that the physical addresses start
5104: // out clean.
5105: //
5106: RtlZeroMemory(
5107: &userPort,
5108: sizeof(userPort)
5109: );
5110: RtlZeroMemory(
5111: &userInterruptStatus,
5112: sizeof(userInterruptStatus)
5113: );
5114:
5115: status = RtlQueryRegistryValues(
5116: RTL_REGISTRY_ABSOLUTE,
5117: parametersPath.Buffer,
5118: parameters,
5119: NULL,
5120: NULL
5121: );
5122:
5123: if (NT_SUCCESS(status)) {
5124:
5125: PCONFIG_DATA newConfig;
5126:
5127: //
5128: // Well! Some supposedly valid information was found!
5129: //
5130: // We'll see about that.
5131: //
5132: // Make sure that the interrupt is non zero (which we defaulted
5133: // it to).
5134: //
5135: // Make sure that the portaddress is non zero (which we defaulted
5136: // it to).
5137: //
5138: // Make sure that the DosDevices is not NULL (which we defaulted
5139: // it to).
5140: //
5141: // We need to make sure that if an interrupt status
5142: // was specified, that a port index was also specfied,
5143: // and if so that the port index is <= maximum ports
5144: // on a board.
5145: //
5146: // We should also validate that the bus type and number
5147: // are correct.
5148: //
5149: // We will also validate that the interrupt mode makes
5150: // sense for the bus.
5151: //
5152:
5153: //
5154: // Let's just jam the WCHAR null at the end of the
5155: // user symbolic link. Remember that we left room for
5156: // one when we allocated it's buffer.
5157: //
5158:
5159: RtlZeroMemory(
5160: ((PUCHAR)(&userSymbolicLink.Buffer[0]))+userSymbolicLink.Length,
5161: sizeof(WCHAR)
5162: );
5163:
5164: if (!userPort.LowPart) {
5165:
5166: //
5167: // Ehhhh! Lose Game.
5168: //
5169:
5170: SerialLogError(
5171: DriverObject,
5172: NULL,
5173: userPort,
5174: SerialPhysicalZero,
5175: 0,
5176: 0,
5177: 0,
5178: 58,
5179: STATUS_SUCCESS,
5180: SERIAL_INVALID_USER_CONFIG,
5181: userSubKey->NameLength+sizeof(WCHAR),
5182: &userSubKey->Name[0],
5183: (wcslen(parameters[1].Name)*sizeof(WCHAR))+sizeof(WCHAR),
5184: parameters[1].Name
5185: );
5186: SerialDump(
5187: SERERRORS,
5188: ("SERIAL: Bogus port address %ws\n",
5189: parameters[1].Name)
5190: );
5191: i++;
5192: continue;
5193:
5194: }
5195:
5196: if (!userVector) {
5197:
5198: //
5199: // Ehhhh! Lose Game.
5200: //
5201:
5202: SerialLogError(
5203: DriverObject,
5204: NULL,
5205: userPort,
5206: SerialPhysicalZero,
5207: 0,
5208: 0,
5209: 0,
5210: 59,
5211: STATUS_SUCCESS,
5212: SERIAL_INVALID_USER_CONFIG,
5213: userSubKey->NameLength+sizeof(WCHAR),
5214: &userSubKey->Name[0],
5215: (wcslen(parameters[2].Name)*sizeof(WCHAR))+sizeof(WCHAR),
5216: parameters[2].Name
5217: );
5218: SerialDump(
5219: SERERRORS,
5220: ("SERIAL: Bogus vector %ws\n",
5221: parameters[2].Name)
5222: );
5223: i++;
5224: continue;
5225:
5226: }
5227:
5228: if (!userSymbolicLink.Length) {
5229:
5230: //
5231: // Ehhhh! Lose Game.
5232: //
5233:
5234: SerialLogError(
5235: DriverObject,
5236: NULL,
5237: userPort,
5238: SerialPhysicalZero,
5239: 0,
5240: 0,
5241: 0,
5242: 60,
5243: STATUS_SUCCESS,
5244: SERIAL_INVALID_USER_CONFIG,
5245: userSubKey->NameLength+sizeof(WCHAR),
5246: &userSubKey->Name[0],
5247: (wcslen(parameters[3].Name)*sizeof(WCHAR))+sizeof(WCHAR),
5248: parameters[3].Name
5249: );
5250: SerialDump(
5251: SERERRORS,
5252: ("SERIAL: bogus value for %ws\n",
5253: parameters[3].Name)
5254: );
5255: i++;
5256: continue;
5257:
5258: }
5259:
5260: if (userInterruptStatus.LowPart != 0) {
5261:
5262: if (userPortIndex == MAXULONG) {
5263:
5264: //
5265: // Ehhhh! Lose Game.
5266: //
5267:
5268: SerialLogError(
5269: DriverObject,
5270: NULL,
5271: userPort,
5272: SerialPhysicalZero,
5273: 0,
5274: 0,
5275: 0,
5276: 30,
5277: STATUS_SUCCESS,
5278: SERIAL_INVALID_PORT_INDEX,
5279: userSymbolicLink.Length+sizeof(WCHAR),
5280: userSymbolicLink.Buffer,
5281: 0,
5282: NULL
5283: );
5284: SerialDump(
5285: SERERRORS,
5286: ("SERIAL: Bogus port index %ws\n",
5287: parameters[0].Name)
5288: );
5289: i++;
5290: continue;
5291:
5292: } else if (!userPortIndex) {
5293:
5294: //
5295: // So sorry, you must have a non-zero port index.
5296: //
5297:
5298: SerialLogError(
5299: DriverObject,
5300: NULL,
5301: userPort,
5302: SerialPhysicalZero,
5303: 0,
5304: 0,
5305: 0,
5306: 31,
5307: STATUS_SUCCESS,
5308: SERIAL_INVALID_PORT_INDEX,
5309: userSymbolicLink.Length+sizeof(WCHAR),
5310: userSymbolicLink.Buffer,
5311: 0,
5312: NULL
5313: );
5314: SerialDump(
5315: SERERRORS,
5316: ("SERIAL: Port index must be > 0 for any\n"
5317: "------- port on a multiport card: %ws\n",
5318: parameters[0].Name)
5319: );
5320: i++;
5321: continue;
5322:
5323: } else {
5324:
5325: if (userIndexed) {
5326:
5327: if (userPortIndex > SERIAL_MAX_PORTS_INDEXED) {
5328:
5329: SerialLogError(
5330: DriverObject,
5331: NULL,
5332: userPort,
5333: SerialPhysicalZero,
5334: 0,
5335: 0,
5336: 0,
5337: 32,
5338: STATUS_SUCCESS,
5339: SERIAL_PORT_INDEX_TOO_HIGH,
5340: userSymbolicLink.Length+sizeof(WCHAR),
5341: userSymbolicLink.Buffer,
5342: 0,
5343: NULL
5344: );
5345: SerialDump(
5346: SERERRORS,
5347: ("SERIAL: port index to large %ws\n",
5348: parameters[0].Name)
5349: );
5350: i++;
5351: continue;
5352:
5353: }
5354:
5355: } else {
5356:
5357: if (userPortIndex > SERIAL_MAX_PORTS_NONINDEXED) {
5358:
5359: SerialLogError(
5360: DriverObject,
5361: NULL,
5362: userPort,
5363: SerialPhysicalZero,
5364: 0,
5365: 0,
5366: 0,
5367: 33,
5368: STATUS_SUCCESS,
5369: SERIAL_PORT_INDEX_TOO_HIGH,
5370: userSymbolicLink.Length+sizeof(WCHAR),
5371: userSymbolicLink.Buffer,
5372: 0,
5373: NULL
5374: );
5375: SerialDump(
5376: SERERRORS,
5377: ("SERIAL: port index to large %ws\n",
5378: parameters[0].Name)
5379: );
5380: i++;
5381: continue;
5382:
5383: }
5384:
5385: }
5386:
5387: }
5388:
5389: }
5390:
5391: //
5392: // We don't want to cause the hal to have a bad day,
5393: // so let's check the interface type and bus number.
5394: //
5395: // We only need to check the registry if they aren't
5396: // equal to the defaults.
5397: //
5398:
5399: if ((userBusNumber != 0) ||
5400: (userInterfaceType != defaultInterfaceType)) {
5401:
5402: BOOLEAN foundIt;
5403: if (userInterfaceType >= MaximumInterfaceType) {
5404:
5405: //
5406: // Ehhhh! Lose Game.
5407: //
5408:
5409: SerialLogError(
5410: DriverObject,
5411: NULL,
5412: userPort,
5413: SerialPhysicalZero,
5414: 0,
5415: 0,
5416: 0,
5417: 34,
5418: STATUS_SUCCESS,
5419: SERIAL_UNKNOWN_BUS,
5420: userSymbolicLink.Length+sizeof(WCHAR),
5421: userSymbolicLink.Buffer,
5422: 0,
5423: NULL
5424: );
5425: SerialDump(
5426: SERERRORS,
5427: ("SERIAL: Invalid Bus type %ws\n",
5428: parameters[0].Name)
5429: );
5430: i++;
5431: continue;
5432:
5433: }
5434:
5435: IoQueryDeviceDescription(
5436: (INTERFACE_TYPE *)&userInterfaceType,
5437: &zero,
5438: NULL,
5439: NULL,
5440: NULL,
5441: NULL,
5442: SerialItemCallBack,
5443: &foundIt
5444: );
5445:
5446: if (!foundIt) {
5447:
5448: SerialLogError(
5449: DriverObject,
5450: NULL,
5451: userPort,
5452: SerialPhysicalZero,
5453: 0,
5454: 0,
5455: 0,
5456: 35,
5457: STATUS_SUCCESS,
5458: SERIAL_BUS_NOT_PRESENT,
5459: userSymbolicLink.Length+sizeof(WCHAR),
5460: userSymbolicLink.Buffer,
5461: 0,
5462: NULL
5463: );
5464: SerialDump(
5465: SERERRORS,
5466: ("SERIAL: There aren't that many of those\n"
5467: "------- busses on this system,%ws\n",
5468: parameters[0].Name)
5469: );
5470: i++;
5471: continue;
5472:
5473: }
5474:
5475: }
5476:
5477: if ((userInterfaceType == MicroChannel) &&
5478: (userInterruptMode == CM_RESOURCE_INTERRUPT_LATCHED)) {
5479:
5480: SerialLogError(
5481: DriverObject,
5482: NULL,
5483: userPort,
5484: SerialPhysicalZero,
5485: 0,
5486: 0,
5487: 0,
5488: 36,
5489: STATUS_SUCCESS,
5490: SERIAL_BUS_INTERRUPT_CONFLICT,
5491: userSymbolicLink.Length+sizeof(WCHAR),
5492: userSymbolicLink.Buffer,
5493: 0,
5494: NULL
5495: );
5496: SerialDump(
5497: SERERRORS,
5498: ("SERIAL: Latched interrupts and MicroChannel\n"
5499: "------- busses don't mix,%ws\n",
5500: parameters[0].Name)
5501: );
5502: i++;
5503: continue;
5504:
5505: }
5506:
5507: //
5508: // Well ok, I guess we can take the data.
5509: // There be other tests later on to make
5510: // sure it doesn't have any other kinds
5511: // of conflicts.
5512: //
5513:
5514: //
5515: // Allocate the config record.
5516: //
5517:
5518: newConfig = ExAllocatePool(
5519: PagedPool,
5520: sizeof(CONFIG_DATA)
5521: );
5522:
5523: if (!newConfig) {
5524:
5525: SerialLogError(
5526: DriverObject,
5527: NULL,
5528: userPort,
5529: SerialPhysicalZero,
5530: 0,
5531: 0,
5532: 0,
5533: 37,
5534: STATUS_SUCCESS,
5535: SERIAL_INSUFFICIENT_RESOURCES,
5536: 0,
5537: NULL,
5538: 0,
5539: NULL
5540: );
5541: SerialDump(
5542: SERERRORS,
5543: ("SERIAL: Couldn't allocate memory for the\n"
5544: "------ user configuration record\n"
5545: "------ for %ws\n",
5546: parameters[0].Name)
5547: );
5548:
5549: i++;
5550: continue;
5551:
5552: }
5553:
5554: RtlZeroMemory(
5555: newConfig,
5556: sizeof(CONFIG_DATA)
5557: );
5558:
5559: //
5560: // Save off a copy of the object directory name.
5561: //
5562:
5563: //
5564: // Init the destination.
5565: //
5566: RtlInitUnicodeString(
5567: &newConfig->ObjectDirectory,
5568: DEFAULT_DIRECTORY
5569: );
5570: newConfig->ObjectDirectory.MaximumLength += sizeof(WCHAR);
5571:
5572: //
5573: // Now allocate that much.
5574: //
5575:
5576: newConfig->ObjectDirectory.Buffer =
5577: ExAllocatePool(
5578: PagedPool,
5579: newConfig->ObjectDirectory.MaximumLength
5580: );
5581:
5582: if (!newConfig->ObjectDirectory.Buffer) {
5583:
5584: SerialLogError(
5585: DriverObject,
5586: NULL,
5587: userPort,
5588: SerialPhysicalZero,
5589: 0,
5590: 0,
5591: 0,
5592: 38,
5593: STATUS_SUCCESS,
5594: SERIAL_INSUFFICIENT_RESOURCES,
5595: 0,
5596: NULL,
5597: 0,
5598: NULL
5599: );
5600: SerialDump(
5601: SERERRORS,
5602: ("SERIAL: Couldn't allocate memory for object\n"
5603: "------ directory for NT user data for: %ws\n",
5604: parameters[0].Name)
5605: );
5606: ExFreePool(newConfig);
5607: i++;
5608: continue;
5609:
5610: } else {
5611:
5612: //
5613: // Zero fill it.
5614: //
5615:
5616: RtlZeroMemory(
5617: newConfig->ObjectDirectory.Buffer,
5618: newConfig->ObjectDirectory.MaximumLength
5619: );
5620:
5621: newConfig->ObjectDirectory.Length = 0;
5622: RtlAppendUnicodeToString(
5623: &newConfig->ObjectDirectory,
5624: DEFAULT_DIRECTORY
5625: );
5626:
5627: }
5628:
5629: //
5630: // Init the destination.
5631: //
5632: RtlInitUnicodeString(
5633: &newConfig->NtNameForPort,
5634: &userSubKey->Name[0]
5635: );
5636:
5637: //
5638: // Allocate the space for the name.
5639: //
5640:
5641: newConfig->NtNameForPort.Length = 0;
5642: newConfig->NtNameForPort.MaximumLength += sizeof(WCHAR);
5643: newConfig->NtNameForPort.Buffer =
5644: ExAllocatePool(
5645: PagedPool,
5646: newConfig->NtNameForPort.MaximumLength
5647: );
5648:
5649: if (!newConfig->NtNameForPort.Buffer) {
5650:
5651: SerialLogError(
5652: DriverObject,
5653: NULL,
5654: userPort,
5655: SerialPhysicalZero,
5656: 0,
5657: 0,
5658: 0,
5659: 39,
5660: STATUS_SUCCESS,
5661: SERIAL_INSUFFICIENT_RESOURCES,
5662: 0,
5663: NULL,
5664: 0,
5665: NULL
5666: );
5667: SerialDump(
5668: SERERRORS,
5669: ("SERIAL: Couldn't allocate memory for NT\n"
5670: "------ name for NT user data name: %ws\n",
5671: parameters[0].Name)
5672: );
5673: ExFreePool(newConfig->ObjectDirectory.Buffer);
5674: ExFreePool(newConfig);
5675: i++;
5676: continue;
5677:
5678: } else {
5679:
5680: RtlZeroMemory(
5681: newConfig->NtNameForPort.Buffer,
5682: newConfig->NtNameForPort.MaximumLength
5683: );
5684:
5685: RtlAppendUnicodeToString(
5686: &newConfig->NtNameForPort,
5687: &userSubKey->Name[0]
5688: );
5689:
5690: }
5691:
5692: newConfig->SymbolicLinkName = userSymbolicLink;
5693: newConfig->SymbolicLinkName.MaximumLength += sizeof(WCHAR);
5694:
5695: newConfig->SymbolicLinkName.Buffer =
5696: ExAllocatePool(
5697: PagedPool,
5698: newConfig->SymbolicLinkName.MaximumLength
5699: );
5700:
5701: if (!newConfig->SymbolicLinkName.Buffer) {
5702:
5703: SerialLogError(
5704: DriverObject,
5705: NULL,
5706: userPort,
5707: SerialPhysicalZero,
5708: 0,
5709: 0,
5710: 0,
5711: 40,
5712: STATUS_SUCCESS,
5713: SERIAL_INSUFFICIENT_RESOURCES,
5714: 0,
5715: NULL,
5716: 0,
5717: NULL
5718: );
5719: SerialDump(
5720: SERERRORS,
5721: ("SERIAL: Couldn't allocate memory for symbolic\n"
5722: "------ name from user data\n"
5723: "------ %ws\n",
5724: parameters[0].Name)
5725: );
5726: ExFreePool(newConfig->ObjectDirectory.Buffer);
5727: ExFreePool(newConfig->NtNameForPort.Buffer);
5728: ExFreePool(newConfig);
5729: i++;
5730: continue;
5731:
5732: } else {
5733:
5734: RtlZeroMemory(
5735: newConfig->SymbolicLinkName.Buffer,
5736: newConfig->SymbolicLinkName.MaximumLength
5737: );
5738:
5739: newConfig->SymbolicLinkName.Length = 0;
5740: RtlAppendUnicodeStringToString(
5741: &newConfig->SymbolicLinkName,
5742: &userSymbolicLink
5743: );
5744:
5745: }
5746:
5747: InitializeListHead(&newConfig->ConfigList);
5748: InitializeListHead(&newConfig->SameInterrupt);
5749: InitializeListHead(&newConfig->SameInterruptStatus);
5750: newConfig->Controller = userPort;
5751: newConfig->InterruptStatus = userInterruptStatus;
5752: newConfig->SpanOfController = SERIAL_REGISTER_SPAN;
5753: newConfig->SpanOfInterruptStatus = SERIAL_STATUS_LENGTH;
5754: newConfig->PortIndex = userPortIndex;
5755: newConfig->ClockRate = userClockRate;
5756: newConfig->BusNumber = userBusNumber;
5757: newConfig->AddressSpace = userAddressSpace;
5758: newConfig->InterruptMode = userInterruptMode;
5759: newConfig->InterfaceType = userInterfaceType;
5760: newConfig->OriginalVector = userVector;
5761: newConfig->DisablePort = disablePort;
5762: newConfig->ForceFifoEnable = forceFifoEnable;
5763: newConfig->RxFIFO = rxFIFO;
5764: if (!userLevel) {
5765: newConfig->OriginalIrql = userVector;
5766: } else {
5767: newConfig->OriginalIrql = userLevel;
5768: }
5769: newConfig->Indexed = userIndexed;
5770: SerialDump(
5771: SERDIAG1,
5772: ("SERIAL: 'user registry info - userPort: %x\n",
5773: userPort.LowPart)
5774: );
5775: SerialDump(
5776: SERDIAG1,
5777: ("SERIAL: 'user registry info - userInterruptStatus: %x\n",
5778: userInterruptStatus.LowPart)
5779: );
5780: SerialDump(
5781: SERDIAG1,
5782: ("SERIAL: 'user registry info - userPortIndex: %d\n",
5783: userPortIndex)
5784: );
5785: SerialDump(
5786: SERDIAG1,
5787: ("SERIAL: 'user registry info - userClockRate: %d\n",
5788: userClockRate)
5789: );
5790: SerialDump(
5791: SERDIAG1,
5792: ("SERIAL: 'user registry info - userBusNumber: %d\n",
5793: userBusNumber)
5794: );
5795: SerialDump(
5796: SERDIAG1,
5797: ("SERIAL: 'user registry info - userAddressSpace: %d\n",
5798: userAddressSpace)
5799: );
5800: SerialDump(
5801: SERDIAG1,
5802: ("SERIAL: 'user registry info - userInterruptMode: %d\n",
5803: userInterruptMode)
5804: );
5805: SerialDump(
5806: SERDIAG1,
5807: ("SERIAL: 'user registry info - userInterfaceType: %d\n",
5808: userInterfaceType)
5809: );
5810: SerialDump(
5811: SERDIAG1,
5812: ("SERIAL: 'user registry info - userVector: %d\n",
5813: userVector)
5814: );
5815: SerialDump(
5816: SERDIAG1,
5817: ("SERIAL: 'user registry info - userLevel: %d\n",
5818: userLevel)
5819: );
5820: SerialDump(
5821: SERDIAG1,
5822: ("SERIAL: 'user registry info - userIndexed: %d\n",
5823: userIndexed)
5824: );
5825:
5826: if (!SerialPutInConfigList(
5827: DriverObject,
5828: ConfigList,
5829: newConfig
5830: )) {
5831:
5832: //
5833: // Dispose of this configuration record.
5834: //
5835:
5836: SerialDump(
5837: SERERRORS,
5838: ("SERIAL: Conflict detected amoungst user data %ws\n",
5839: parameters[0].Name)
5840: );
5841:
5842: ExFreePool(newConfig->ObjectDirectory.Buffer);
5843: ExFreePool(newConfig->NtNameForPort.Buffer);
5844: ExFreePool(newConfig->SymbolicLinkName.Buffer);
5845: ExFreePool(newConfig);
5846:
5847: }
5848:
5849: i++;
5850:
5851: } else {
5852:
5853: SerialLogError(
5854: DriverObject,
5855: NULL,
5856: SerialPhysicalZero,
5857: SerialPhysicalZero,
5858: 0,
5859: 0,
5860: 0,
5861: 61,
5862: status,
5863: SERIAL_INVALID_USER_CONFIG,
5864: userSubKey->NameLength+sizeof(WCHAR),
5865: &userSubKey->Name[0],
5866: 0,
5867: NULL
5868: );
5869: SerialDump(
5870: SERERRORS,
5871: ("SERIAL: Bad status returned: %x \n"
5872: "------- for the value entries of\n"
5873: "------- %ws\n",
5874: status,parameters[0].Name)
5875: );
5876:
5877: i++;
5878:
5879: }
5880:
5881: }
5882:
5883: ZwClose(parametersKey);
5884:
5885: DoFirmwareAdd:;
5886:
5887: //
5888: // All done with the user specified information. Now try
5889: // to add the firmware specified data to the configuration.
5890: // If a conflict is detected then we simply dispose of that
5891: // firmware collected data.
5892: //
5893:
5894: while (!IsListEmpty(&firmware.ConfigList)) {
5895:
5896: PLIST_ENTRY head;
5897: PCONFIG_DATA firmwareData;
5898:
5899: head = RemoveHeadList(&firmware.ConfigList);
5900:
5901: firmwareData = CONTAINING_RECORD(
5902: head,
5903: CONFIG_DATA,
5904: ConfigList
5905: );
5906:
5907:
5908: firmwareData->Jensen = jensenDetected;
5909:
5910: if (!SerialPutInConfigList(
5911: DriverObject,
5912: ConfigList,
5913: firmwareData
5914: )) {
5915:
5916: //
5917: // Dispose of this configuration record.
5918: //
5919:
5920: SerialLogError(
5921: DriverObject,
5922: NULL,
5923: firmwareData->Controller,
5924: SerialPhysicalZero,
5925: 0,
5926: 0,
5927: 0,
5928: 42,
5929: STATUS_SUCCESS,
5930: SERIAL_USER_OVERRIDE,
5931: firmwareData->SymbolicLinkName.Length+sizeof(WCHAR),
5932: firmwareData->SymbolicLinkName.Buffer,
5933: 0,
5934: NULL
5935: );
5936: SerialDump(
5937: SERERRORS,
5938: ("SERIAL: Conflict detected with user data for firmware port %wZ\n"
5939: "------ User data will overides firmware data\n",
5940: &firmwareData->NtNameForPort)
5941: );
5942: ExFreePool(firmwareData->ObjectDirectory.Buffer);
5943: ExFreePool(firmwareData->NtNameForPort.Buffer);
5944: ExFreePool(firmwareData->SymbolicLinkName.Buffer);
5945: ExFreePool(firmwareData);
5946:
5947: }
5948:
5949: }
5950:
5951: if (userSubKey) {
5952:
5953: ExFreePool(userSubKey);
5954:
5955: }
5956:
5957: if (userSymbolicLink.Buffer) {
5958:
5959: ExFreePool(userSymbolicLink.Buffer);
5960:
5961: }
5962:
5963: if (parametersPath.Buffer) {
5964:
5965: ExFreePool(parametersPath.Buffer);
5966:
5967: }
5968:
5969: if (parameters) {
5970:
5971: ExFreePool(parameters);
5972:
5973: }
5974: }
5975:
5976: BOOLEAN
5977: SerialPutInConfigList(
5978: IN PDRIVER_OBJECT DriverObject,
5979: IN OUT PLIST_ENTRY ConfigList,
5980: IN PCONFIG_DATA New
5981: )
5982:
5983: /*++
5984:
5985: Routine Description:
5986:
5987: Given an interrupt value, port address, interrupt status address,
5988: and an already defined list of configuration records, this routine
5989: will perform a check to make sure that the new record doesn't
5990: conflict with old records. (Note that we also include a port
5991: index, but this has no bearing on validation.)
5992:
5993: If everything checks out it will create a new configuration
5994: record if the new record isn't part of multiport card or
5995: if it is part of a multiport card it will create a configuration
5996: record if the specifiers for that multiport card don't already
5997: exist.
5998:
5999: NOTE: It is assumed throughout this code that no address is
6000: specified as 0.
6001:
6002: We assume nothing is zero because that for interrupt
6003: status that means none was specified.
6004:
6005: Arguments:
6006:
6007: DriverObject - Used to log errors.
6008:
6009: ConfigList - Listhead for a list of configuration records for
6010: ports to control.
6011:
6012: New = Pointer to new configuration record to add.
6013:
6014: Return Value:
6015:
6016: This will return STATUS_SUCCESS this new port information
6017: does not conflict with old port information. Otherwise it
6018: will return STATUS_SERIAL_NO_DEVICE_INITED.
6019:
6020: --*/
6021:
6022: {
6023:
6024: PHYSICAL_ADDRESS serialPhysicalMax;
6025:
6026: serialPhysicalMax.LowPart = (ULONG)~0;
6027: serialPhysicalMax.HighPart = ~0;
6028:
6029: SerialDump(
6030: SERDIAG1,
6031: ("SERIAL: Attempting to add %wZ\n"
6032: "------- to the config list\n"
6033: "------- PortAddress is %x\n"
6034: "------- Interrupt Status is %x\n"
6035: "------- BusNumber is %d\n"
6036: "------- BusType is %d\n"
6037: "------- AddressSpace is %d\n",
6038: &New->NtNameForPort,
6039: New->Controller.LowPart,
6040: New->InterruptStatus.LowPart,
6041: New->BusNumber,
6042: New->InterfaceType,
6043: New->AddressSpace
6044: )
6045: );
6046:
6047: //
6048: // We don't support any boards whose memory wraps around
6049: // the physical address space.
6050: //
6051:
6052: if (SerialMemCompare(
6053: New->Controller,
6054: New->SpanOfController,
6055: serialPhysicalMax,
6056: (ULONG)0
6057: ) != AddressesAreDisjoint) {
6058:
6059: SerialLogError(
6060: DriverObject,
6061: NULL,
6062: New->Controller,
6063: SerialPhysicalZero,
6064: 0,
6065: 0,
6066: 0,
6067: 43,
6068: STATUS_SUCCESS,
6069: SERIAL_DEVICE_TOO_HIGH,
6070: New->SymbolicLinkName.Length+sizeof(WCHAR),
6071: New->SymbolicLinkName.Buffer,
6072: 0,
6073: NULL
6074: );
6075: SerialDump(
6076: SERERRORS,
6077: ("SERIAL: Error in config record for %wZ\n"
6078: "------ registers rap around physical memory\n",
6079: &New->NtNameForPort)
6080: );
6081: return FALSE;
6082:
6083: }
6084:
6085: if (SerialMemCompare(
6086: New->InterruptStatus,
6087: New->SpanOfInterruptStatus,
6088: serialPhysicalMax,
6089: (ULONG)0
6090: ) != AddressesAreDisjoint) {
6091:
6092: SerialLogError(
6093: DriverObject,
6094: NULL,
6095: New->Controller,
6096: SerialPhysicalZero,
6097: 0,
6098: 0,
6099: 0,
6100: 44,
6101: STATUS_SUCCESS,
6102: SERIAL_STATUS_TOO_HIGH,
6103: New->SymbolicLinkName.Length+sizeof(WCHAR),
6104: New->SymbolicLinkName.Buffer,
6105: 0,
6106: NULL
6107: );
6108: SerialDump(
6109: SERERRORS,
6110: ("SERIAL: Error in config record for %wZ\n"
6111: "------ status raps around physical memory\n",
6112: &New->NtNameForPort)
6113: );
6114: return FALSE;
6115:
6116: }
6117:
6118: //
6119: // Make sure that the interrupt status address doesn't
6120: // overlap the controller registers
6121: //
6122:
6123: if (SerialMemCompare(
6124: New->InterruptStatus,
6125: New->SpanOfInterruptStatus,
6126: SerialPhysicalZero,
6127: (ULONG)0
6128: ) != AddressesAreEqual) {
6129:
6130: if (SerialMemCompare(
6131: New->InterruptStatus,
6132: New->SpanOfInterruptStatus,
6133: New->Controller,
6134: New->SpanOfController
6135: ) != AddressesAreDisjoint) {
6136:
6137: SerialLogError(
6138: DriverObject,
6139: NULL,
6140: New->Controller,
6141: New->InterruptStatus,
6142: 0,
6143: 0,
6144: 0,
6145: 45,
6146: STATUS_SUCCESS,
6147: SERIAL_STATUS_CONTROL_CONFLICT,
6148: New->SymbolicLinkName.Length+sizeof(WCHAR),
6149: New->SymbolicLinkName.Buffer,
6150: 0,
6151: NULL
6152: );
6153: SerialDump(
6154: SERERRORS,
6155: ("SERIAL: Error in cofig record for %wZ\n"
6156: "------- Interrupt status overlaps regular registers\n",
6157: &New->NtNameForPort)
6158: );
6159: return FALSE;
6160:
6161: }
6162:
6163: }
6164:
6165: //
6166: // Loop through all of the old configuration records making
6167: // sure that this new record doesn't overlap with any of
6168: // the old records.
6169: //
6170:
6171: if (!IsListEmpty(ConfigList)) {
6172:
6173: PLIST_ENTRY CurrentConfigListEntry = ConfigList->Flink;
6174:
6175: do {
6176:
6177: PCONFIG_DATA CurrentSameIntConfig = CONTAINING_RECORD(
6178: CurrentConfigListEntry,
6179: CONFIG_DATA,
6180: ConfigList
6181: );
6182:
6183: //
6184: // We only care about this list if the elements are on the
6185: // same bus as this new entry.
6186: //
6187:
6188: if ((CurrentSameIntConfig->InterfaceType == New->InterfaceType) &&
6189: (CurrentSameIntConfig->AddressSpace == New->AddressSpace) &&
6190: (CurrentSameIntConfig->BusNumber == New->BusNumber)) {
6191:
6192: PLIST_ENTRY RootSameIntListEntry = &CurrentSameIntConfig->SameInterrupt;
6193: PLIST_ENTRY CurrentSameIntListEntry = RootSameIntListEntry;
6194:
6195: do {
6196:
6197: PLIST_ENTRY RootSameStatusListEntry = &CONTAINING_RECORD(
6198: CurrentSameIntListEntry,
6199: CONFIG_DATA,
6200: SameInterrupt
6201: )->SameInterruptStatus;
6202: PLIST_ENTRY CurrentSameStatusListEntry = RootSameStatusListEntry;
6203:
6204: do {
6205:
6206: PCONFIG_DATA OldConfig = CONTAINING_RECORD(
6207: CurrentSameStatusListEntry,
6208: CONFIG_DATA,
6209: SameInterruptStatus
6210: );
6211:
6212: SerialDump(
6213: SERDIAG1,
6214: ("SERIAL: Comparing it to %wZ\n"
6215: "------- already in the config list\n"
6216: "------- PortAddress is %x\n"
6217: "------- Interrupt Status is %x\n"
6218: "------- BusNumber is %d\n"
6219: "------- BusType is %d\n"
6220: "------- AddressSpace is %d\n",
6221: &OldConfig->NtNameForPort,
6222: OldConfig->Controller.LowPart,
6223: OldConfig->InterruptStatus.LowPart,
6224: OldConfig->BusNumber,
6225: OldConfig->InterfaceType,
6226: OldConfig->AddressSpace
6227: )
6228: );
6229:
6230: if (SerialMemCompare(
6231: New->Controller,
6232: New->SpanOfController,
6233: OldConfig->Controller,
6234: OldConfig->SpanOfController
6235: ) != AddressesAreDisjoint) {
6236:
6237: SerialLogError(
6238: DriverObject,
6239: NULL,
6240: New->Controller,
6241: OldConfig->Controller,
6242: 0,
6243: 0,
6244: 0,
6245: 46,
6246: STATUS_SUCCESS,
6247: SERIAL_CONTROL_OVERLAP,
6248: New->SymbolicLinkName.Length+sizeof(WCHAR),
6249: New->SymbolicLinkName.Buffer,
6250: OldConfig->SymbolicLinkName.Length+sizeof(WCHAR),
6251: OldConfig->SymbolicLinkName.Buffer
6252: );
6253: SerialDump(
6254: SERERRORS,
6255: ("SERIAL: Error in config record for %wZ\n"
6256: "------- Register address overlaps with\n"
6257: "------- previous serial device\n",
6258: &New->NtNameForPort)
6259: );
6260: return FALSE;
6261:
6262: }
6263:
6264: //
6265: // If we have an interrupt status, make sure that
6266: // it doesn't overlap with the old controllers
6267: // registers.
6268: //
6269:
6270: if (SerialMemCompare(
6271: New->InterruptStatus,
6272: New->SpanOfInterruptStatus,
6273: SerialPhysicalZero,
6274: (ULONG)0
6275: ) != AddressesAreEqual) {
6276:
6277: if (SerialMemCompare(
6278: New->InterruptStatus,
6279: New->SpanOfInterruptStatus,
6280: OldConfig->Controller,
6281: OldConfig->SpanOfController
6282: ) != AddressesAreDisjoint) {
6283:
6284: SerialLogError(
6285: DriverObject,
6286: NULL,
6287: New->Controller,
6288: OldConfig->Controller,
6289: 0,
6290: 0,
6291: 0,
6292: 47,
6293: STATUS_SUCCESS,
6294: SERIAL_STATUS_OVERLAP,
6295: New->SymbolicLinkName.Length+sizeof(WCHAR),
6296: New->SymbolicLinkName.Buffer,
6297: OldConfig->SymbolicLinkName.Length+sizeof(WCHAR),
6298: OldConfig->SymbolicLinkName.Buffer
6299: );
6300: SerialDump(
6301: SERERRORS,
6302: ("SERIAL: Error in config record for %wZ\n"
6303: "------- status address overlaps with\n"
6304: "------- previous serial device registers\n",
6305: &New->NtNameForPort)
6306: );
6307:
6308: return FALSE;
6309:
6310: }
6311:
6312: //
6313: // If the old configuration record has an interrupt
6314: // status, the addresses should not overlap.
6315: //
6316:
6317: if (SerialMemCompare(
6318: OldConfig->InterruptStatus,
6319: OldConfig->SpanOfInterruptStatus,
6320: SerialPhysicalZero,
6321: (ULONG)0
6322: ) != AddressesAreEqual) {
6323:
6324: if (SerialMemCompare(
6325: New->InterruptStatus,
6326: New->SpanOfInterruptStatus,
6327: OldConfig->InterruptStatus,
6328: OldConfig->SpanOfInterruptStatus
6329: ) == AddressesOverlap) {
6330:
6331: SerialLogError(
6332: DriverObject,
6333: NULL,
6334: New->Controller,
6335: OldConfig->Controller,
6336: 0,
6337: 0,
6338: 0,
6339: 48,
6340: STATUS_SUCCESS,
6341: SERIAL_STATUS_STATUS_OVERLAP,
6342: New->SymbolicLinkName.Length+sizeof(WCHAR),
6343: New->SymbolicLinkName.Buffer,
6344: OldConfig->SymbolicLinkName.Length+sizeof(WCHAR),
6345: OldConfig->SymbolicLinkName.Buffer
6346: );
6347: SerialDump(
6348: SERERRORS,
6349: ("SERIAL: Error in config record for %wZ\n"
6350: "------- status address overlaps with\n"
6351: "------- previous serial status register\n",
6352: &New->NtNameForPort)
6353: );
6354:
6355: return FALSE;
6356:
6357: }
6358:
6359: }
6360:
6361: }
6362:
6363: //
6364: // If the old configuration record has a status
6365: // address make sure that it doesn't overlap with
6366: // the new controllers address. (Interrupt status
6367: // overlap is take care of above.
6368: //
6369:
6370: if (SerialMemCompare(
6371: OldConfig->InterruptStatus,
6372: OldConfig->SpanOfInterruptStatus,
6373: SerialPhysicalZero,
6374: (ULONG)0
6375: ) != AddressesAreEqual) {
6376:
6377: if (SerialMemCompare(
6378: New->Controller,
6379: New->SpanOfController,
6380: OldConfig->InterruptStatus,
6381: OldConfig->SpanOfInterruptStatus
6382: ) == AddressesOverlap) {
6383:
6384: SerialLogError(
6385: DriverObject,
6386: NULL,
6387: New->Controller,
6388: OldConfig->Controller,
6389: 0,
6390: 0,
6391: 0,
6392: 49,
6393: STATUS_SUCCESS,
6394: SERIAL_CONTROL_STATUS_OVERLAP,
6395: New->SymbolicLinkName.Length+sizeof(WCHAR),
6396: New->SymbolicLinkName.Buffer,
6397: OldConfig->SymbolicLinkName.Length+sizeof(WCHAR),
6398: OldConfig->SymbolicLinkName.Buffer
6399: );
6400: SerialDump(
6401: SERERRORS,
6402: ("SERIAL: Error in config record for %wZ\n"
6403: "------- register address overlaps with\n"
6404: "------- previous serial status register\n",
6405: &New->NtNameForPort)
6406: );
6407:
6408: return FALSE;
6409:
6410: }
6411:
6412: }
6413:
6414: CurrentSameStatusListEntry = CurrentSameStatusListEntry->Flink;
6415:
6416: } while (CurrentSameStatusListEntry != RootSameStatusListEntry);
6417:
6418: CurrentSameIntListEntry = CurrentSameIntListEntry->Flink;
6419:
6420: } while (CurrentSameIntListEntry != RootSameIntListEntry);
6421:
6422: }
6423:
6424: CurrentConfigListEntry = CurrentConfigListEntry->Flink;
6425:
6426: } while (CurrentConfigListEntry != ConfigList);
6427: }
6428:
6429: //
6430: // If there is an interrupt status then we
6431: // loop through the config list again to look
6432: // for a config record with the same interrupt
6433: // status (on the same bus).
6434: //
6435:
6436: if ((SerialMemCompare(
6437: New->InterruptStatus,
6438: New->SpanOfInterruptStatus,
6439: SerialPhysicalZero,
6440: (ULONG)0
6441: ) != AddressesAreEqual) &&
6442: !IsListEmpty(ConfigList)) {
6443:
6444: //
6445: // We have an interrupt status. Loop through all
6446: // previous records, look for an existing interrupt status
6447: // the same as the current interrupt status.
6448: //
6449:
6450: PLIST_ENTRY CurrentConfigListEntry = ConfigList->Flink;
6451:
6452: do {
6453:
6454: PCONFIG_DATA CurrentSameIntConfig = CONTAINING_RECORD(
6455: CurrentConfigListEntry,
6456: CONFIG_DATA,
6457: ConfigList
6458: );
6459:
6460: //
6461: // We only care about this list if the elements are on the
6462: // same bus as this new entry. (There interrupts must therfore
6463: // also be the on the same bus. We will check that momentarily).
6464: //
6465: // We don't check here for the dissimilar interrupts since that
6466: // could cause us to miss the error of having the same interrupt
6467: // status but different interrupts - which is bizzare.
6468: //
6469:
6470: if ((CurrentSameIntConfig->InterfaceType == New->InterfaceType) &&
6471: (CurrentSameIntConfig->AddressSpace == New->AddressSpace) &&
6472: (CurrentSameIntConfig->BusNumber == New->BusNumber)) {
6473:
6474: PLIST_ENTRY RootSameIntListEntry = &CurrentSameIntConfig->SameInterrupt;
6475: PLIST_ENTRY CurrentSameIntListEntry = RootSameIntListEntry;
6476:
6477: do {
6478:
6479: PLIST_ENTRY RootSameStatusListEntry = &CONTAINING_RECORD(
6480: CurrentSameIntListEntry,
6481: CONFIG_DATA,
6482: SameInterrupt
6483: )->SameInterruptStatus;
6484: PLIST_ENTRY CurrentSameStatusListEntry = RootSameStatusListEntry;
6485:
6486: do {
6487:
6488: PCONFIG_DATA OldConfig = CONTAINING_RECORD(
6489: CurrentSameStatusListEntry,
6490: CONFIG_DATA,
6491: SameInterruptStatus
6492: );
6493:
6494: //
6495: // If the interrupt status
6496: //
6497:
6498: if (SerialMemCompare(
6499: OldConfig->InterruptStatus,
6500: OldConfig->SpanOfInterruptStatus,
6501: New->InterruptStatus,
6502: New->SpanOfInterruptStatus
6503: ) == AddressesAreEqual) {
6504:
6505: //
6506: // Same card. Now make sure that they
6507: // are using the same interrupt parameters.
6508: //
6509:
6510: if ((New->OriginalIrql != OldConfig->OriginalIrql) ||
6511: (New->OriginalVector != OldConfig->OriginalVector)) {
6512:
6513: //
6514: // We won't put this into the configuration
6515: // list.
6516: //
6517:
6518: SerialLogError(
6519: DriverObject,
6520: NULL,
6521: New->Controller,
6522: OldConfig->Controller,
6523: 0,
6524: 0,
6525: 0,
6526: 50,
6527: STATUS_SUCCESS,
6528: SERIAL_MULTI_INTERRUPT_CONFLICT,
6529: New->SymbolicLinkName.Length+sizeof(WCHAR),
6530: New->SymbolicLinkName.Buffer,
6531: OldConfig->SymbolicLinkName.Length+sizeof(WCHAR),
6532: OldConfig->SymbolicLinkName.Buffer
6533: );
6534: SerialDump(
6535: SERERRORS,
6536: ("SERIAL: Configuration error for %wZ\n"
6537: "------- Same multiport - different interrupts\n",
6538: &New->NtNameForPort)
6539: );
6540: return FALSE;
6541:
6542: }
6543:
6544: //
6545: // Place this new record on the SameInterruptStatus
6546: // as the old record.
6547: //
6548:
6549: InitializeListHead(&New->SameInterruptStatus);
6550:
6551: InsertTailList(
6552: &OldConfig->SameInterruptStatus,
6553: &New->SameInterruptStatus
6554: );
6555:
6556: return TRUE;
6557:
6558: }
6559:
6560: CurrentSameStatusListEntry = CurrentSameStatusListEntry->Flink;
6561:
6562: } while (CurrentSameStatusListEntry != RootSameStatusListEntry);
6563:
6564: CurrentSameIntListEntry = CurrentSameIntListEntry->Flink;
6565:
6566: } while (CurrentSameIntListEntry != RootSameIntListEntry);
6567:
6568: }
6569:
6570: CurrentConfigListEntry = CurrentConfigListEntry->Flink;
6571:
6572: } while (CurrentConfigListEntry != ConfigList);
6573:
6574: }
6575:
6576: //
6577: // Go through the list again looking for previous devices
6578: // with the same interrupt.
6579: //
6580:
6581: if (!IsListEmpty(ConfigList)) {
6582:
6583: PLIST_ENTRY CurrentConfigListEntry = ConfigList->Flink;
6584:
6585: do {
6586:
6587: PCONFIG_DATA OldConfig = CONTAINING_RECORD(
6588: CurrentConfigListEntry,
6589: CONFIG_DATA,
6590: ConfigList
6591: );
6592:
6593: //
6594: // We only care about interrupts that are on
6595: // the same bus.
6596: //
6597:
6598: if ((OldConfig->InterfaceType == New->InterfaceType) &&
6599: (OldConfig->BusNumber == New->BusNumber)) {
6600:
6601: if ((OldConfig->OriginalIrql == New->OriginalIrql) &&
6602: (OldConfig->OriginalVector == New->OriginalVector)) {
6603:
6604: InsertTailList(
6605: &OldConfig->SameInterrupt,
6606: &New->SameInterrupt
6607: );
6608:
6609: return TRUE;
6610:
6611: }
6612:
6613: }
6614:
6615: CurrentConfigListEntry = CurrentConfigListEntry->Flink;
6616:
6617: } while (CurrentConfigListEntry != ConfigList);
6618:
6619: }
6620:
6621: //
6622: // This port doesn't appear to be sharing with
6623: // anything. Just put it on the config list.
6624: //
6625:
6626: InsertTailList(
6627: ConfigList,
6628: &New->ConfigList
6629: );
6630:
6631: return TRUE;
6632:
6633: }
6634:
6635: PVOID
6636: SerialGetMappedAddress(
6637: IN INTERFACE_TYPE BusType,
6638: IN ULONG BusNumber,
6639: PHYSICAL_ADDRESS IoAddress,
6640: ULONG NumberOfBytes,
6641: ULONG AddressSpace,
6642: PBOOLEAN MappedAddress
6643: )
6644:
6645: /*++
6646:
6647: Routine Description:
6648:
6649: This routine maps an IO address to system address space.
6650:
6651: Arguments:
6652:
6653: BusType - what type of bus - eisa, mca, isa
6654: IoBusNumber - which IO bus (for machines with multiple buses).
6655: IoAddress - base device address to be mapped.
6656: NumberOfBytes - number of bytes for which address is valid.
6657: AddressSpace - Denotes whether the address is in io space or memory.
6658: MappedAddress - indicates whether the address was mapped.
6659: This only has meaning if the address returned
6660: is non-null.
6661:
6662: Return Value:
6663:
6664: Mapped address
6665:
6666: --*/
6667:
6668: {
6669: PHYSICAL_ADDRESS cardAddress;
6670: PVOID address;
6671:
6672: HalTranslateBusAddress(
6673: BusType,
6674: BusNumber,
6675: IoAddress,
6676: &AddressSpace,
6677: &cardAddress
6678: );
6679:
6680: //
6681: // Map the device base address into the virtual address space
6682: // if the address is in memory space.
6683: //
6684:
6685: if (!AddressSpace) {
6686:
6687: address = MmMapIoSpace(
6688: cardAddress,
6689: NumberOfBytes,
6690: FALSE
6691: );
6692:
6693: *MappedAddress = (BOOLEAN)((address)?(TRUE):(FALSE));
6694:
6695:
6696: } else {
6697:
6698: address = (PVOID)cardAddress.LowPart;
6699: *MappedAddress = FALSE;
6700:
6701: }
6702:
6703: return address;
6704:
6705: }
6706:
6707: VOID
6708: SerialSetupExternalNaming(
6709: IN PSERIAL_DEVICE_EXTENSION Extension
6710: )
6711:
6712: /*++
6713:
6714: Routine Description:
6715:
6716: This routine will be used to create a symbolic link
6717: to the driver name in the given object directory.
6718:
6719: It will also create an entry in the device map for
6720: this device - IF we could create the symbolic link.
6721:
6722: Arguments:
6723:
6724: Extension - Pointer to the device extension.
6725:
6726: Return Value:
6727:
6728: None.
6729:
6730: --*/
6731:
6732: {
6733:
6734: UNICODE_STRING fullLinkName;
6735: NTSTATUS status;
6736:
6737: //
6738: // Form the full symbolic link name we wish to create.
6739: //
6740:
6741: RtlInitUnicodeString(
6742: &fullLinkName,
6743: NULL
6744: );
6745:
6746: //
6747: // Allocate some pool for the name.
6748: //
6749:
6750: fullLinkName.MaximumLength = (sizeof(L"\\")*2) +
6751: Extension->ObjectDirectory.Length+
6752: Extension->SymbolicLinkName.Length+
6753: sizeof(WCHAR);
6754:
6755:
6756:
6757: fullLinkName.Buffer = ExAllocatePool(
6758: PagedPool,
6759: fullLinkName.MaximumLength
6760: );
6761:
6762: if (!fullLinkName.Buffer) {
6763:
6764: //
6765: // Couldn't allocate space for the name.
6766: //
6767:
6768: SerialLogError(
6769: Extension->DeviceObject->DriverObject,
6770: Extension->DeviceObject,
6771: Extension->OriginalController,
6772: SerialPhysicalZero,
6773: 0,
6774: 0,
6775: 0,
6776: 51,
6777: STATUS_SUCCESS,
6778: SERIAL_INSUFFICIENT_RESOURCES,
6779: 0,
6780: NULL,
6781: 0,
6782: NULL
6783: );
6784: SerialDump(
6785: SERERRORS,
6786: ("SERIAL: Couldn't allocate space for the symbolic \n"
6787: "------- name for creating the link\n"
6788: "------- for port %wZ\n",
6789: &Extension->DeviceName)
6790: );
6791:
6792: } else {
6793:
6794: RtlZeroMemory(
6795: fullLinkName.Buffer,
6796: fullLinkName.MaximumLength
6797: );
6798:
6799: RtlAppendUnicodeToString(
6800: &fullLinkName,
6801: L"\\"
6802: );
6803:
6804: RtlAppendUnicodeStringToString(
6805: &fullLinkName,
6806: &Extension->ObjectDirectory
6807: );
6808:
6809: RtlAppendUnicodeToString(
6810: &fullLinkName,
6811: L"\\"
6812: );
6813:
6814: RtlAppendUnicodeStringToString(
6815: &fullLinkName,
6816: &Extension->SymbolicLinkName
6817: );
6818:
6819:
6820: status = IoCreateSymbolicLink(
6821: &fullLinkName,
6822: &Extension->DeviceName
6823: );
6824: if (!NT_SUCCESS(status)) {
6825:
6826: //
6827: // Oh well, couldn't create the symbolic link. No point
6828: // in trying to create the device map entry.
6829: //
6830:
6831: SerialLogError(
6832: Extension->DeviceObject->DriverObject,
6833: Extension->DeviceObject,
6834: Extension->OriginalController,
6835: SerialPhysicalZero,
6836: 0,
6837: 0,
6838: 0,
6839: 52,
6840: status,
6841: SERIAL_NO_SYMLINK_CREATED,
6842: Extension->SymbolicLinkName.Length+sizeof(WCHAR),
6843: Extension->SymbolicLinkName.Buffer,
6844: 0,
6845: NULL
6846: );
6847: SerialDump(
6848: SERERRORS,
6849: ("SERIAL: Couldn't create the symbolic link\n"
6850: "------- for port %wZ\n",
6851: &Extension->DeviceName)
6852: );
6853:
6854: } else {
6855:
6856: Extension->CreatedSymbolicLink = TRUE;
6857:
6858: status = RtlWriteRegistryValue(
6859: RTL_REGISTRY_DEVICEMAP,
6860: L"SERIALCOMM",
6861: Extension->NtNameForPort.Buffer,
6862: REG_SZ,
6863: Extension->SymbolicLinkName.Buffer,
6864: Extension->SymbolicLinkName.Length+sizeof(WCHAR)
6865: );
6866:
6867: if (!NT_SUCCESS(status)) {
6868:
6869: SerialLogError(
6870: Extension->DeviceObject->DriverObject,
6871: Extension->DeviceObject,
6872: Extension->OriginalController,
6873: SerialPhysicalZero,
6874: 0,
6875: 0,
6876: 0,
6877: 53,
6878: status,
6879: SERIAL_NO_DEVICE_MAP_CREATED,
6880: Extension->SymbolicLinkName.Length+sizeof(WCHAR),
6881: Extension->SymbolicLinkName.Buffer,
6882: 0,
6883: NULL
6884: );
6885: SerialDump(
6886: SERERRORS,
6887: ("SERIAL: Couldn't create the device map entry\n"
6888: "------- for port %wZ\n",
6889: &Extension->DeviceName)
6890: );
6891:
6892: }
6893:
6894: }
6895:
6896: ExFreePool(fullLinkName.Buffer);
6897:
6898: }
6899:
6900: }
6901:
6902: VOID
6903: SerialCleanupExternalNaming(
6904: IN PSERIAL_DEVICE_EXTENSION Extension
6905: )
6906:
6907: /*++
6908:
6909: Routine Description:
6910:
6911: This routine will be used to delete a symbolic link
6912: to the driver name in the given object directory.
6913:
6914: It will also delete an entry in the device map for
6915: this device if the symbolic link had been created.
6916:
6917: Arguments:
6918:
6919: Extension - Pointer to the device extension.
6920:
6921: Return Value:
6922:
6923: None.
6924:
6925: --*/
6926:
6927: {
6928:
6929: UNICODE_STRING fullLinkName;
6930:
6931: SerialDump(
6932: SERDIAG3,
6933: ("SERIAL: In SerialCleanupExternalNaming for\n"
6934: "------- extension: %x of port %wZ\n",
6935: Extension,&Extension->DeviceName)
6936: );
6937:
6938: //
6939: // We're cleaning up here. One reason we're cleaning up
6940: // is that we couldn't allocate space for the directory
6941: // name or the symbolic link.
6942: //
6943:
6944: if (Extension->ObjectDirectory.Buffer &&
6945: Extension->SymbolicLinkName.Buffer &&
6946: Extension->CreatedSymbolicLink) {
6947:
6948: //
6949: // Form the full symbolic link name we wish to create.
6950: //
6951:
6952: RtlInitUnicodeString(
6953: &fullLinkName,
6954: NULL
6955: );
6956:
6957: //
6958: // Allocate some pool for the name.
6959: //
6960:
6961: fullLinkName.MaximumLength = (sizeof(L"\\")*2) +
6962: Extension->ObjectDirectory.Length+
6963: Extension->SymbolicLinkName.Length+
6964: sizeof(WCHAR);
6965:
6966: fullLinkName.Buffer = ExAllocatePool(
6967: PagedPool,
6968: fullLinkName.MaximumLength
6969: );
6970:
6971: if (!fullLinkName.Buffer) {
6972:
6973: //
6974: // Couldn't allocate space for the name. Just go on
6975: // to the device map stuff.
6976: //
6977:
6978: SerialLogError(
6979: Extension->DeviceObject->DriverObject,
6980: Extension->DeviceObject,
6981: Extension->OriginalController,
6982: SerialPhysicalZero,
6983: 0,
6984: 0,
6985: 0,
6986: 54,
6987: STATUS_SUCCESS,
6988: SERIAL_INSUFFICIENT_RESOURCES,
6989: 0,
6990: NULL,
6991: 0,
6992: NULL
6993: );
6994: SerialDump(
6995: SERERRORS,
6996: ("SERIAL: Couldn't allocate space for the symbolic \n"
6997: "------- name for creating the link\n"
6998: "------- for port %wZ on cleanup\n",
6999: &Extension->DeviceName)
7000: );
7001:
7002: } else {
7003:
7004: RtlZeroMemory(
7005: fullLinkName.Buffer,
7006: fullLinkName.MaximumLength
7007: );
7008:
7009: RtlAppendUnicodeToString(
7010: &fullLinkName,
7011: L"\\"
7012: );
7013:
7014: RtlAppendUnicodeStringToString(
7015: &fullLinkName,
7016: &Extension->ObjectDirectory
7017: );
7018:
7019: RtlAppendUnicodeToString(
7020: &fullLinkName,
7021: L"\\"
7022: );
7023:
7024: RtlAppendUnicodeStringToString(
7025: &fullLinkName,
7026: &Extension->SymbolicLinkName
7027: );
7028:
7029: IoDeleteSymbolicLink(&fullLinkName);
7030:
7031: ExFreePool(fullLinkName.Buffer);
7032:
7033: }
7034:
7035: //
7036: // We're cleaning up here. One reason we're cleaning up
7037: // is that we couldn't allocate space for the NtNameOfPort.
7038: //
7039:
7040: if (Extension->NtNameForPort.Buffer) {
7041:
7042: NTSTATUS status;
7043:
7044: status = RtlDeleteRegistryValue(
7045: RTL_REGISTRY_DEVICEMAP,
7046: L"SERIALCOMM",
7047: Extension->NtNameForPort.Buffer
7048: );
7049:
7050: if (!NT_SUCCESS(status)) {
7051:
7052: SerialLogError(
7053: Extension->DeviceObject->DriverObject,
7054: Extension->DeviceObject,
7055: Extension->OriginalController,
7056: SerialPhysicalZero,
7057: 0,
7058: 0,
7059: 0,
7060: 55,
7061: status,
7062: SERIAL_NO_DEVICE_MAP_DELETED,
7063: Extension->SymbolicLinkName.Length+sizeof(WCHAR),
7064: Extension->SymbolicLinkName.Buffer,
7065: 0,
7066: NULL
7067: );
7068: SerialDump(
7069: SERERRORS,
7070: ("SERIAL: Couldn't delete value entry %wZ\n",
7071: &Extension->DeviceName)
7072: );
7073:
7074: }
7075:
7076: }
7077:
7078: }
7079:
7080: }
7081:
7082: SERIAL_MEM_COMPARES
7083: SerialMemCompare(
7084: IN PHYSICAL_ADDRESS A,
7085: IN ULONG SpanOfA,
7086: IN PHYSICAL_ADDRESS B,
7087: IN ULONG SpanOfB
7088: )
7089:
7090: /*++
7091:
7092: Routine Description:
7093:
7094: Compare two phsical address.
7095:
7096: Arguments:
7097:
7098: A - One half of the comparison.
7099:
7100: SpanOfA - In units of bytes, the span of A.
7101:
7102: B - One half of the comparison.
7103:
7104: SpanOfB - In units of bytes, the span of B.
7105:
7106:
7107: Return Value:
7108:
7109: The result of the comparison.
7110:
7111: --*/
7112:
7113: {
7114:
7115: LARGE_INTEGER a;
7116: LARGE_INTEGER b;
7117:
7118: LARGE_INTEGER lower;
7119: ULONG lowerSpan;
7120: LARGE_INTEGER higher;
7121:
7122: a.LowPart = A.LowPart;
7123: a.HighPart = A.HighPart;
7124: b.LowPart = B.LowPart;
7125: b.HighPart = B.HighPart;
7126:
7127: if (RtlLargeIntegerEqualTo(
7128: a,
7129: b
7130: )) {
7131:
7132: return AddressesAreEqual;
7133:
7134: }
7135:
7136: if (RtlLargeIntegerGreaterThan(
7137: a,
7138: b
7139: )) {
7140:
7141: higher = a;
7142: lower = b;
7143: lowerSpan = SpanOfB;
7144:
7145: } else {
7146:
7147: higher = b;
7148: lower = a;
7149: lowerSpan = SpanOfA;
7150:
7151: }
7152:
7153: if (RtlLargeIntegerGreaterThanOrEqualTo(
7154: RtlLargeIntegerSubtract(
7155: higher,
7156: lower
7157: ),
7158: RtlConvertUlongToLargeInteger(lowerSpan)
7159: )) {
7160:
7161: return AddressesAreDisjoint;
7162:
7163: }
7164:
7165: return AddressesOverlap;
7166:
7167: }
7168:
7169: VOID
7170: SerialLogError(
7171: IN PDRIVER_OBJECT DriverObject,
7172: IN PDEVICE_OBJECT DeviceObject OPTIONAL,
7173: IN PHYSICAL_ADDRESS P1,
7174: IN PHYSICAL_ADDRESS P2,
7175: IN ULONG SequenceNumber,
7176: IN UCHAR MajorFunctionCode,
7177: IN UCHAR RetryCount,
7178: IN ULONG UniqueErrorValue,
7179: IN NTSTATUS FinalStatus,
7180: IN NTSTATUS SpecificIOStatus,
7181: IN ULONG LengthOfInsert1,
7182: IN PWCHAR Insert1,
7183: IN ULONG LengthOfInsert2,
7184: IN PWCHAR Insert2
7185: )
7186:
7187: /*++
7188:
7189: Routine Description:
7190:
7191: This routine allocates an error log entry, copies the supplied data
7192: to it, and requests that it be written to the error log file.
7193:
7194: Arguments:
7195:
7196: DriverObject - A pointer to the driver object for the device.
7197:
7198: DeviceObject - A pointer to the device object associated with the
7199: device that had the error, early in initialization, one may not
7200: yet exist.
7201:
7202: P1,P2 - If phyical addresses for the controller ports involved
7203: with the error are available, put them through as dump data.
7204:
7205: SequenceNumber - A ulong value that is unique to an IRP over the
7206: life of the irp in this driver - 0 generally means an error not
7207: associated with an irp.
7208:
7209: MajorFunctionCode - If there is an error associated with the irp,
7210: this is the major function code of that irp.
7211:
7212: RetryCount - The number of times a particular operation has been
7213: retried.
7214:
7215: UniqueErrorValue - A unique long word that identifies the particular
7216: call to this function.
7217:
7218: FinalStatus - The final status given to the irp that was associated
7219: with this error. If this log entry is being made during one of
7220: the retries this value will be STATUS_SUCCESS.
7221:
7222: SpecificIOStatus - The IO status for a particular error.
7223:
7224: LengthOfInsert1 - The length in bytes (including the terminating NULL)
7225: of the first insertion string.
7226:
7227: Insert1 - The first insertion string.
7228:
7229: LengthOfInsert2 - The length in bytes (including the terminating NULL)
7230: of the second insertion string. NOTE, there must
7231: be a first insertion string for their to be
7232: a second insertion string.
7233:
7234: Insert2 - The second insertion string.
7235:
7236: Return Value:
7237:
7238: None.
7239:
7240: --*/
7241:
7242: {
7243: PIO_ERROR_LOG_PACKET errorLogEntry;
7244:
7245: PVOID objectToUse;
7246: SHORT dumpToAllocate = 0;
7247: PUCHAR ptrToFirstInsert;
7248: PUCHAR ptrToSecondInsert;
7249:
7250:
7251: if (ARGUMENT_PRESENT(DeviceObject)) {
7252:
7253: objectToUse = DeviceObject;
7254:
7255: } else {
7256:
7257: objectToUse = DriverObject;
7258:
7259: }
7260:
7261: if (SerialMemCompare(
7262: P1,
7263: (ULONG)1,
7264: SerialPhysicalZero,
7265: (ULONG)1
7266: ) != AddressesAreEqual) {
7267:
7268: dumpToAllocate = (SHORT)sizeof(PHYSICAL_ADDRESS);
7269:
7270: }
7271:
7272: if (SerialMemCompare(
7273: P2,
7274: (ULONG)1,
7275: SerialPhysicalZero,
7276: (ULONG)1
7277: ) != AddressesAreEqual) {
7278:
7279: dumpToAllocate += (SHORT)sizeof(PHYSICAL_ADDRESS);
7280:
7281: }
7282:
7283: errorLogEntry = IoAllocateErrorLogEntry(
7284: objectToUse,
7285: (UCHAR)(sizeof(IO_ERROR_LOG_PACKET) +
7286: dumpToAllocate + LengthOfInsert1 +
7287: LengthOfInsert2)
7288: );
7289:
7290: if ( errorLogEntry != NULL ) {
7291:
7292: errorLogEntry->ErrorCode = SpecificIOStatus;
7293: errorLogEntry->SequenceNumber = SequenceNumber;
7294: errorLogEntry->MajorFunctionCode = MajorFunctionCode;
7295: errorLogEntry->RetryCount = RetryCount;
7296: errorLogEntry->UniqueErrorValue = UniqueErrorValue;
7297: errorLogEntry->FinalStatus = FinalStatus;
7298: errorLogEntry->DumpDataSize = dumpToAllocate;
7299:
7300: if (dumpToAllocate) {
7301:
7302: RtlCopyMemory(
7303: &errorLogEntry->DumpData[0],
7304: &P1,
7305: sizeof(PHYSICAL_ADDRESS)
7306: );
7307:
7308: if (dumpToAllocate > sizeof(PHYSICAL_ADDRESS)) {
7309:
7310: RtlCopyMemory(
7311: ((PUCHAR)&errorLogEntry->DumpData[0])+sizeof(PHYSICAL_ADDRESS),
7312: &P2,
7313: sizeof(PHYSICAL_ADDRESS)
7314: );
7315:
7316: ptrToFirstInsert =
7317: ((PUCHAR)&errorLogEntry->DumpData[0])+(2*sizeof(PHYSICAL_ADDRESS));
7318:
7319: } else {
7320:
7321: ptrToFirstInsert =
7322: ((PUCHAR)&errorLogEntry->DumpData[0])+sizeof(PHYSICAL_ADDRESS);
7323:
7324:
7325: }
7326:
7327: } else {
7328:
7329: ptrToFirstInsert = (PUCHAR)&errorLogEntry->DumpData[0];
7330:
7331: }
7332:
7333: ptrToSecondInsert = ptrToFirstInsert + LengthOfInsert1;
7334:
7335: if (LengthOfInsert1) {
7336:
7337: errorLogEntry->NumberOfStrings = 1;
7338: errorLogEntry->StringOffset = (USHORT)(ptrToFirstInsert -
7339: (PUCHAR)errorLogEntry);
7340: RtlCopyMemory(
7341: ptrToFirstInsert,
7342: Insert1,
7343: LengthOfInsert1
7344: );
7345:
7346: if (LengthOfInsert2) {
7347:
7348: errorLogEntry->NumberOfStrings = 2;
7349: RtlCopyMemory(
7350: ptrToSecondInsert,
7351: Insert2,
7352: LengthOfInsert2
7353: );
7354:
7355: }
7356:
7357: }
7358:
7359: IoWriteErrorLogEntry(errorLogEntry);
7360:
7361: }
7362:
7363: }
7364:
7365: VOID
7366: SerialUnReportResourcesDevice(
7367: IN PSERIAL_DEVICE_EXTENSION Extension
7368: )
7369:
7370: /*++
7371:
7372: Routine Description:
7373:
7374: This routine *un*reports the resources used for a device that
7375: is "ready" to run. If some conflict was detected, it doesn't
7376: matter, the reources are *un*reported.
7377:
7378: Arguments:
7379:
7380: Extension - The device extension of the device we are *un*reporting
7381: resources for.
7382:
7383: Return Value:
7384:
7385: None.
7386:
7387: --*/
7388:
7389: {
7390:
7391: CM_RESOURCE_LIST resourceList;
7392: ULONG sizeOfResourceList = 0;
7393: UNICODE_STRING className;
7394: BOOLEAN junkBoolean;
7395:
7396: SerialDump(
7397: SERDIAG3,
7398: ("SERIAL: In SerialUnreportResourcesDevice\n"
7399: "------- for extension %x of port %wZ\n",
7400: Extension,&Extension->DeviceName)
7401: );
7402: RtlZeroMemory(
7403: &resourceList,
7404: sizeof(CM_RESOURCE_LIST)
7405: );
7406:
7407: resourceList.Count = 0;
7408:
7409: RtlInitUnicodeString(
7410: &className,
7411: L"LOADED SERIAL DRIVER RESOURCES"
7412: );
7413:
7414: IoReportResourceUsage(
7415: &className,
7416: Extension->DeviceObject->DriverObject,
7417: NULL,
7418: 0,
7419: Extension->DeviceObject,
7420: &resourceList,
7421: sizeof(CM_RESOURCE_LIST),
7422: FALSE,
7423: &junkBoolean
7424: );
7425:
7426: }
7427:
7428: VOID
7429: SerialReportResourcesDevice(
7430: IN PSERIAL_DEVICE_EXTENSION Extension,
7431: OUT BOOLEAN *ConflictDetected
7432: )
7433:
7434: /*++
7435:
7436: Routine Description:
7437:
7438: This routine reports the resources used for a device that
7439: is "ready" to run. If some conflict was detected, it doesn't
7440: matter, the reources are reported.
7441:
7442: Arguments:
7443:
7444: Extension - The device extension of the device we are reporting
7445: resources for.
7446:
7447: ConflictDetected - Pointer to a boolean that we will pass
7448: to the resource reporting code.
7449:
7450: Return Value:
7451:
7452: None.
7453:
7454: --*/
7455:
7456: {
7457:
7458: PCM_RESOURCE_LIST resourceList;
7459: ULONG sizeOfResourceList;
7460: ULONG countOfPartials;
7461: PCM_PARTIAL_RESOURCE_DESCRIPTOR partial;
7462: UNICODE_STRING className;
7463:
7464: SerialDump(
7465: SERDIAG3,
7466: ("SERIAL: In SerialReportResourcesDevice\n"
7467: "------- for extension %x of port %wZ\n",
7468: Extension,&Extension->DeviceName)
7469: );
7470:
7471: //
7472: // The resource list for a device will consist of
7473: //
7474: // The resource list record itself with a count
7475: // of one for the single "built in" full resource
7476: // descriptor.
7477: //
7478: // The built-in full resource descriptor will contain
7479: // the bus type and busnumber and the built in partial
7480: // resource list.
7481: //
7482: // The built in partial resource list will have at
7483: // least a count of 2:
7484: //
7485: // 1) The interrupt that this device will be
7486: // coming in on.
7487: //
7488: // 2) The base register physical address and it's span.
7489: //
7490: // The built in partial resource list will have a
7491: // count of 3 if it has an interrupt status address
7492: // That interrupt status address will consist of
7493: // the physical address and the span (normally 1).
7494: //
7495:
7496: countOfPartials = Extension->InterruptStatus?3:2;
7497: sizeOfResourceList = sizeof(CM_RESOURCE_LIST) +
7498: (sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR)*
7499: (countOfPartials-1));
7500:
7501: resourceList = ExAllocatePool(
7502: PagedPool,
7503: sizeOfResourceList
7504: );
7505:
7506: if (!resourceList) {
7507:
7508: //
7509: // Oh well, can't allocate the memory. Act as though
7510: // we succeeded.
7511: //
7512:
7513: SerialLogError(
7514: Extension->DeviceObject->DriverObject,
7515: Extension->DeviceObject,
7516: Extension->OriginalController,
7517: SerialPhysicalZero,
7518: 0,
7519: 0,
7520: 0,
7521: 56,
7522: STATUS_SUCCESS,
7523: SERIAL_INSUFFICIENT_RESOURCES,
7524: 0,
7525: NULL,
7526: 0,
7527: NULL
7528: );
7529: return;
7530:
7531: }
7532:
7533: RtlZeroMemory(
7534: resourceList,
7535: sizeOfResourceList
7536: );
7537:
7538: resourceList->Count = 1;
7539:
7540:
7541: resourceList->List[0].InterfaceType = Extension->InterfaceType;
7542: resourceList->List[0].BusNumber = Extension->BusNumber;
7543: resourceList->List[0].PartialResourceList.Count = countOfPartials;
7544: partial = &resourceList->List[0].PartialResourceList.PartialDescriptors[0];
7545:
7546: //
7547: // Account for the space used by the controller.
7548: //
7549:
7550: partial->Type = CmResourceTypePort;
7551: partial->ShareDisposition = CmResourceShareDeviceExclusive;
7552: partial->Flags = (USHORT)Extension->AddressSpace;
7553: partial->u.Port.Start = Extension->OriginalController;
7554: partial->u.Port.Length = Extension->SpanOfController;
7555:
7556: partial++;
7557:
7558: //
7559: // Report the interrupt information.
7560: //
7561:
7562: partial->Type = CmResourceTypeInterrupt;
7563:
7564: if (Extension->InterruptShareable) {
7565:
7566: partial->ShareDisposition = CmResourceShareShared;
7567:
7568: } else {
7569:
7570: partial->ShareDisposition = CmResourceShareDriverExclusive;
7571:
7572: }
7573:
7574: if (Extension->InterruptMode == Latched) {
7575:
7576: partial->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
7577:
7578: } else {
7579:
7580: partial->Flags = CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE;
7581:
7582: }
7583:
7584: partial->u.Interrupt.Vector = Extension->OriginalVector;
7585: partial->u.Interrupt.Level = Extension->OriginalIrql;
7586:
7587: //
7588: // We have an interrupt status register. Report it.
7589: //
7590:
7591: if (countOfPartials == 3) {
7592:
7593: partial++;
7594:
7595: partial->Type = CmResourceTypePort;
7596: partial->ShareDisposition = CmResourceShareDriverExclusive;
7597: partial->Flags = (USHORT)Extension->AddressSpace;
7598: partial->u.Port.Start = Extension->OriginalInterruptStatus;
7599: partial->u.Port.Length = Extension->SpanOfInterruptStatus;
7600:
7601: }
7602:
7603: RtlInitUnicodeString(
7604: &className,
7605: L"LOADED SERIAL DRIVER RESOURCES"
7606: );
7607:
7608: IoReportResourceUsage(
7609: &className,
7610: Extension->DeviceObject->DriverObject,
7611: NULL,
7612: 0,
7613: Extension->DeviceObject,
7614: resourceList,
7615: sizeOfResourceList,
7616: FALSE,
7617: ConflictDetected
7618: );
7619:
7620: ExFreePool(resourceList);
7621:
7622: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.