IRP_MN_START_DEVICE implement for ROOT FDO (PciFdoStartDevice)
[reactos.git] / reactos / drivers / bus / pcix / utils.c
1 /*
2 * PROJECT: ReactOS PCI Bus Driver
3 * LICENSE: BSD - See COPYING.ARM in the top level directory
4 * FILE: drivers/bus/pci/utils.c
5 * PURPOSE: Utility/Helper Support Code
6 * PROGRAMMERS: ReactOS Portable Systems Group
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #include <pci.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 /* GLOBALS ********************************************************************/
16
17 RTL_RANGE_LIST PciIsaBitExclusionList;
18 RTL_RANGE_LIST PciVgaAndIsaBitExclusionList;
19
20 /* FUNCTIONS ******************************************************************/
21
22 BOOLEAN
23 NTAPI
24 PciUnicodeStringStrStr(IN PUNICODE_STRING InputString,
25 IN PCUNICODE_STRING EqualString,
26 IN BOOLEAN CaseInSensitive)
27 {
28 UNICODE_STRING PartialString;
29 LONG EqualChars, TotalChars;
30
31 /* Build a partial string with the smaller substring */
32 PartialString.Length = EqualString->Length;
33 PartialString.MaximumLength = InputString->MaximumLength;;
34 PartialString.Buffer = InputString->Buffer;
35
36 /* Check how many characters that need comparing */
37 EqualChars = 0;
38 TotalChars = (InputString->Length - EqualString->Length) / sizeof(WCHAR);
39
40 /* If the substring is bigger, just fail immediately */
41 if (TotalChars < 0) return FALSE;
42
43 /* Keep checking each character */
44 while (!RtlEqualUnicodeString(EqualString, &PartialString, CaseInSensitive))
45 {
46 /* Continue checking until all the required characters are equal */
47 PartialString.Buffer++;
48 PartialString.MaximumLength -= sizeof(WCHAR);
49 if (++EqualChars > TotalChars) return FALSE;
50 }
51
52 /* The string is equal */
53 return TRUE;
54 }
55
56 BOOLEAN
57 NTAPI
58 PciStringToUSHORT(IN PWCHAR String,
59 OUT PUSHORT Value)
60 {
61 USHORT Short;
62 ULONG Low, High, Length;
63 WCHAR Char;
64
65 /* Initialize everything to zero */
66 Short = 0;
67 Length = 0;
68 while (TRUE)
69 {
70 /* Get the character and set the high byte based on the previous one */
71 Char = *String++;
72 High = 16 * Short;
73
74 /* Check for numbers */
75 if ( Char >= '0' && Char <= '9' )
76 {
77 /* Convert them to a byte */
78 Low = Char - '0';
79 }
80 else if ( Char >= 'A' && Char <= 'F' )
81 {
82 /* Convert upper-case hex letters into a byte */
83 Low = Char - '7';
84 }
85 else if ( Char >= 'a' && Char <= 'f' )
86 {
87 /* Convert lower-case hex letters into a byte */
88 Low = Char - 'W';
89 }
90 else
91 {
92 /* Invalid string, fail the conversion */
93 return FALSE;
94 }
95
96 /* Combine the high and low byte */
97 Short = High | Low;
98
99 /* If 4 letters have been reached, the 16-bit integer should exist */
100 if (++Length >= 4)
101 {
102 /* Return it to the caller */
103 *Value = Short;
104 return TRUE;
105 }
106 }
107 }
108
109 BOOLEAN
110 NTAPI
111 PciIsSuiteVersion(IN USHORT SuiteMask)
112 {
113 ULONGLONG Mask = 0;
114 RTL_OSVERSIONINFOEXW VersionInfo;
115
116 /* Initialize the version information */
117 RtlZeroMemory(&VersionInfo, sizeof(RTL_OSVERSIONINFOEXW));
118 VersionInfo.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
119 VersionInfo.wSuiteMask = SuiteMask;
120
121 /* Set the comparison mask and return if the passed suite mask matches */
122 VER_SET_CONDITION(Mask, VER_SUITENAME, VER_AND);
123 return NT_SUCCESS(RtlVerifyVersionInfo(&VersionInfo, VER_SUITENAME, Mask));
124 }
125
126 BOOLEAN
127 NTAPI
128 PciIsDatacenter(VOID)
129 {
130 BOOLEAN Result;
131 PVOID Value;
132 ULONG ResultLength;
133 NTSTATUS Status;
134
135 /* Assume this isn't Datacenter */
136 Result = FALSE;
137
138 /* First, try opening the setup key */
139 Status = PciGetRegistryValue(L"",
140 L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Services\\setupdd",
141 0,
142 REG_BINARY,
143 &Value,
144 &ResultLength);
145 if (!NT_SUCCESS(Status))
146 {
147 /* This is not an in-progress Setup boot, so query the suite version */
148 Result = PciIsSuiteVersion(VER_SUITE_DATACENTER);
149 }
150 else
151 {
152 /* This scenario shouldn't happen yet, since SetupDD isn't used */
153 UNIMPLEMENTED;
154 while (TRUE);
155 }
156
157 /* Return if this is Datacenter or not */
158 return Result;
159 }
160
161 BOOLEAN
162 NTAPI
163 PciOpenKey(IN PWCHAR KeyName,
164 IN HANDLE RootKey,
165 IN ACCESS_MASK DesiredAccess,
166 OUT PHANDLE KeyHandle,
167 OUT PNTSTATUS KeyStatus)
168 {
169 NTSTATUS Status;
170 OBJECT_ATTRIBUTES ObjectAttributes;
171 UNICODE_STRING KeyString;
172 PAGED_CODE();
173
174 /* Initialize the object attributes */
175 RtlInitUnicodeString(&KeyString, KeyName);
176 InitializeObjectAttributes(&ObjectAttributes,
177 &KeyString,
178 OBJ_CASE_INSENSITIVE,
179 RootKey,
180 NULL);
181
182 /* Open the key, returning a boolean, and the status, if requested */
183 Status = ZwOpenKey(KeyHandle, DesiredAccess, &ObjectAttributes);
184 if (KeyStatus) *KeyStatus = Status;
185 return NT_SUCCESS(Status);
186 }
187
188 NTSTATUS
189 NTAPI
190 PciGetRegistryValue(IN PWCHAR ValueName,
191 IN PWCHAR KeyName,
192 IN HANDLE RootHandle,
193 IN ULONG Type,
194 OUT PVOID *OutputBuffer,
195 OUT PULONG OutputLength)
196 {
197 NTSTATUS Status;
198 PKEY_VALUE_PARTIAL_INFORMATION PartialInfo;
199 ULONG NeededLength, ActualLength;
200 UNICODE_STRING ValueString;
201 HANDLE KeyHandle;
202 BOOLEAN Result;
203
204 /* So we know what to free at the end of the body */
205 PartialInfo = NULL;
206 KeyHandle = NULL;
207 do
208 {
209 /* Open the key by name, rooted off the handle passed */
210 Result = PciOpenKey(KeyName,
211 RootHandle,
212 KEY_QUERY_VALUE,
213 &KeyHandle,
214 &Status);
215 if (!Result) break;
216
217 /* Query for the size that's needed for the value that was passed in */
218 RtlInitUnicodeString(&ValueString, ValueName);
219 Status = ZwQueryValueKey(KeyHandle,
220 &ValueString,
221 KeyValuePartialInformation,
222 NULL,
223 0,
224 &NeededLength);
225 ASSERT(!NT_SUCCESS(Status));
226 if (Status != STATUS_BUFFER_TOO_SMALL) break;
227
228 /* Allocate an appropriate buffer for the size that was returned */
229 ASSERT(NeededLength != 0);
230 Status = STATUS_INSUFFICIENT_RESOURCES;
231 PartialInfo = ExAllocatePoolWithTag(PagedPool,
232 NeededLength,
233 PCI_POOL_TAG);
234 if (!PartialInfo) break;
235
236 /* Query the actual value information now that the size is known */
237 Status = ZwQueryValueKey(KeyHandle,
238 &ValueString,
239 KeyValuePartialInformation,
240 PartialInfo,
241 NeededLength,
242 &ActualLength);
243 if (!NT_SUCCESS(Status)) break;
244
245 /* Make sure it's of the type that the caller expects */
246 Status = STATUS_INVALID_PARAMETER;
247 if (PartialInfo->Type != Type) break;
248
249 /* Subtract the registry-specific header, to get the data size */
250 ASSERT(NeededLength == ActualLength);
251 NeededLength -= sizeof(KEY_VALUE_PARTIAL_INFORMATION);
252
253 /* Allocate a buffer to hold the data and return it to the caller */
254 Status = STATUS_INSUFFICIENT_RESOURCES;
255 *OutputBuffer = ExAllocatePoolWithTag(PagedPool,
256 NeededLength,
257 PCI_POOL_TAG);
258 if (!*OutputBuffer) break;
259
260 /* Copy the data into the buffer and return its length to the caller */
261 RtlCopyMemory(*OutputBuffer, PartialInfo->Data, NeededLength);
262 if (OutputLength) *OutputLength = NeededLength;
263 Status = STATUS_SUCCESS;
264 } while (0);
265
266 /* Close any opened keys and free temporary allocations */
267 if (KeyHandle) ZwClose(KeyHandle);
268 if (PartialInfo) ExFreePoolWithTag(PartialInfo, 0);
269 return Status;
270 }
271
272 NTSTATUS
273 NTAPI
274 PciBuildDefaultExclusionLists(VOID)
275 {
276 ULONG Start;
277 NTSTATUS Status;
278 ASSERT(PciIsaBitExclusionList.Count == 0);
279 ASSERT(PciVgaAndIsaBitExclusionList.Count == 0);
280
281 /* Initialize the range lists */
282 RtlInitializeRangeList(&PciIsaBitExclusionList);
283 RtlInitializeRangeList(&PciVgaAndIsaBitExclusionList);
284
285 /* Loop x86 I/O ranges */
286 for (Start = 0x100; Start <= 0xFEFF; Start += 0x400)
287 {
288 /* Add the ISA I/O ranges */
289 Status = RtlAddRange(&PciIsaBitExclusionList,
290 Start,
291 Start + 0x2FF,
292 0,
293 RTL_RANGE_LIST_ADD_IF_CONFLICT,
294 NULL,
295 NULL);
296 if (!NT_SUCCESS(Status)) break;
297
298 /* Add the ISA I/O ranges */
299 Status = RtlAddRange(&PciVgaAndIsaBitExclusionList,
300 Start,
301 Start + 0x2AF,
302 0,
303 RTL_RANGE_LIST_ADD_IF_CONFLICT,
304 NULL,
305 NULL);
306 if (!NT_SUCCESS(Status)) break;
307
308 /* Add the VGA I/O range for Monochrome Video */
309 Status = RtlAddRange(&PciVgaAndIsaBitExclusionList,
310 Start + 0x2BC,
311 Start + 0x2BF,
312 0,
313 RTL_RANGE_LIST_ADD_IF_CONFLICT,
314 NULL,
315 NULL);
316 if (!NT_SUCCESS(Status)) break;
317
318 /* Add the VGA I/O range for certain CGA adapters */
319 Status = RtlAddRange(&PciVgaAndIsaBitExclusionList,
320 Start + 0x2E0,
321 Start + 0x2FF,
322 0,
323 RTL_RANGE_LIST_ADD_IF_CONFLICT,
324 NULL,
325 NULL);
326 if (!NT_SUCCESS(Status)) break;
327
328 /* Success, ranges added done */
329 };
330
331 RtlFreeRangeList(&PciIsaBitExclusionList);
332 RtlFreeRangeList(&PciVgaAndIsaBitExclusionList);
333 return Status;
334 }
335
336 PPCI_FDO_EXTENSION
337 NTAPI
338 PciFindParentPciFdoExtension(IN PDEVICE_OBJECT DeviceObject,
339 IN PKEVENT Lock)
340 {
341 PPCI_FDO_EXTENSION FoundExtension;
342
343 /* Assume we'll find nothing */
344 FoundExtension = NULL;
345
346 /* Check if a lock was specified */
347 if (Lock)
348 {
349 /* Wait for the lock to be released */
350 KeEnterCriticalRegion();
351 KeWaitForSingleObject(Lock, Executive, KernelMode, FALSE, NULL);
352 }
353
354 /* Now search for the extension */
355 if (PciFdoExtensionListHead.Next)
356 {
357 /* This case should not be hit yet */
358 UNIMPLEMENTED;
359 while (TRUE);
360 }
361
362 /* Check if we had acquired a lock previously */
363 if (Lock)
364 {
365 /* Release it */
366 KeSetEvent(Lock, IO_NO_INCREMENT, FALSE);
367 KeLeaveCriticalRegion();
368 }
369
370 /* Return which extension was found, if any */
371 return FoundExtension;
372 }
373
374 VOID
375 NTAPI
376 PciInsertEntryAtTail(IN PSINGLE_LIST_ENTRY ListHead,
377 IN PPCI_FDO_EXTENSION DeviceExtension,
378 IN PKEVENT Lock)
379 {
380 PSINGLE_LIST_ENTRY NextEntry;
381 PAGED_CODE();
382
383 /* Check if a lock was specified */
384 if (Lock)
385 {
386 /* Wait for the lock to be released */
387 KeEnterCriticalRegion();
388 KeWaitForSingleObject(Lock, Executive, KernelMode, FALSE, NULL);
389 }
390
391 /* Loop the list until we get to the end, then insert this entry there */
392 for (NextEntry = ListHead; NextEntry->Next; NextEntry = NextEntry->Next);
393 NextEntry->Next = &DeviceExtension->List;
394
395 /* Check if we had acquired a lock previously */
396 if (Lock)
397 {
398 /* Release it */
399 KeSetEvent(Lock, IO_NO_INCREMENT, FALSE);
400 KeLeaveCriticalRegion();
401 }
402 }
403
404 VOID
405 NTAPI
406 PciInsertEntryAtHead(IN PSINGLE_LIST_ENTRY ListHead,
407 IN PSINGLE_LIST_ENTRY Entry,
408 IN PKEVENT Lock)
409 {
410 PAGED_CODE();
411
412 /* Check if a lock was specified */
413 if (Lock)
414 {
415 /* Wait for the lock to be released */
416 KeEnterCriticalRegion();
417 KeWaitForSingleObject(Lock, Executive, KernelMode, FALSE, NULL);
418 }
419
420 /* Make the entry point to the current head and make the head point to it */
421 Entry->Next = ListHead->Next;
422 ListHead->Next = Entry;
423
424 /* Check if we had acquired a lock previously */
425 if (Lock)
426 {
427 /* Release it */
428 KeSetEvent(Lock, IO_NO_INCREMENT, FALSE);
429 KeLeaveCriticalRegion();
430 }
431 }
432
433 VOID
434 NTAPI
435 PcipLinkSecondaryExtension(IN PSINGLE_LIST_ENTRY List,
436 IN PVOID Lock,
437 IN PPCI_SECONDARY_EXTENSION SecondaryExtension,
438 IN PCI_SIGNATURE ExtensionType,
439 IN PVOID Destructor)
440 {
441 PAGED_CODE();
442
443 /* Setup the extension data, and insert it into the primary's list */
444 SecondaryExtension->ExtensionType = ExtensionType;
445 SecondaryExtension->Destructor = Destructor;
446 PciInsertEntryAtHead(List, &SecondaryExtension->List, Lock);
447 }
448
449 NTSTATUS
450 NTAPI
451 PciGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject,
452 IN DEVICE_REGISTRY_PROPERTY DeviceProperty,
453 OUT PVOID *OutputBuffer)
454 {
455 NTSTATUS Status;
456 ULONG BufferLength, ResultLength;
457 PVOID Buffer;
458 do
459 {
460 /* Query the requested property size */
461 Status = IoGetDeviceProperty(DeviceObject,
462 DeviceProperty,
463 0,
464 NULL,
465 &BufferLength);
466 if (Status != STATUS_BUFFER_TOO_SMALL)
467 {
468 /* Call should've failed with buffer too small! */
469 DPRINT1("PCI - Unexpected status from GetDeviceProperty, saw %08X, expected %08X.\n",
470 Status,
471 STATUS_BUFFER_TOO_SMALL);
472 *OutputBuffer = NULL;
473 ASSERTMSG(FALSE, "PCI Successfully did the impossible!");
474 break;
475 }
476
477 /* Allocate the required buffer */
478 Buffer = ExAllocatePoolWithTag(PagedPool, BufferLength, 'BicP');
479 if (!Buffer)
480 {
481 /* No memory, fail the request */
482 DPRINT1("PCI - Failed to allocate DeviceProperty buffer (%d bytes).\n", BufferLength);
483 Status = STATUS_INSUFFICIENT_RESOURCES;
484 break;
485 }
486
487 /* Do the actual property query call */
488 Status = IoGetDeviceProperty(DeviceObject,
489 DeviceProperty,
490 BufferLength,
491 Buffer,
492 &ResultLength);
493 if (!NT_SUCCESS(Status)) break;
494
495 /* Return the buffer to the caller */
496 ASSERT(BufferLength == ResultLength);
497 *OutputBuffer = Buffer;
498 return STATUS_SUCCESS;
499 } while (FALSE);
500
501 /* Failure path */
502 return STATUS_UNSUCCESSFUL;
503 }
504
505 NTSTATUS
506 NTAPI
507 PciSendIoctl(IN PDEVICE_OBJECT DeviceObject,
508 IN ULONG IoControlCode,
509 IN PVOID InputBuffer,
510 IN ULONG InputBufferLength,
511 IN PVOID OutputBuffer,
512 IN ULONG OutputBufferLength)
513 {
514 PIRP Irp;
515 NTSTATUS Status;
516 KEVENT Event;
517 IO_STATUS_BLOCK IoStatusBlock;
518 PDEVICE_OBJECT AttachedDevice;
519 PAGED_CODE();
520
521 /* Initialize the pending IRP event */
522 KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
523
524 /* Get a reference to the root PDO (ACPI) */
525 AttachedDevice = IoGetAttachedDeviceReference(DeviceObject);
526 if (!AttachedDevice) return STATUS_INVALID_PARAMETER;
527
528 /* Build the requested IOCTL IRP */
529 Irp = IoBuildDeviceIoControlRequest(IoControlCode,
530 AttachedDevice,
531 InputBuffer,
532 InputBufferLength,
533 OutputBuffer,
534 OutputBufferLength,
535 0,
536 &Event,
537 &IoStatusBlock);
538 if (!Irp) return STATUS_INSUFFICIENT_RESOURCES;
539
540 /* Send the IOCTL to the driver */
541 Status = IoCallDriver(AttachedDevice, Irp);
542 if (Status == STATUS_PENDING)
543 {
544 /* Wait for a response */
545 KeWaitForSingleObject(&Event,
546 Executive,
547 KernelMode,
548 FALSE,
549 NULL);
550 Status = Irp->IoStatus.Status;
551 }
552
553 /* Take away the reference we took and return the result to the caller */
554 ObDereferenceObject(AttachedDevice);
555 return Status;
556 }
557
558 PPCI_SECONDARY_EXTENSION
559 NTAPI
560 PciFindNextSecondaryExtension(IN PSINGLE_LIST_ENTRY ListHead,
561 IN PCI_SIGNATURE ExtensionType)
562 {
563 PSINGLE_LIST_ENTRY NextEntry;
564 PPCI_SECONDARY_EXTENSION Extension;
565
566 /* Scan the list */
567 for (NextEntry = ListHead; NextEntry; NextEntry = NextEntry->Next)
568 {
569 /* Grab each extension and check if it's the one requested */
570 Extension = CONTAINING_RECORD(NextEntry, PCI_SECONDARY_EXTENSION, List);
571 if (Extension->ExtensionType == ExtensionType) return Extension;
572 }
573
574 /* Nothing was found */
575 return NULL;
576 }
577
578 /* EOF */