[NTOS]
[reactos.git] / reactos / ntoskrnl / io / pnpmgr / pnpinit.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: BSD - See COPYING.ARM in the top level directory
4 * FILE: ntoskrnl/io/pnpmgr/pnpinit.c
5 * PURPOSE: PnP Initialization Code
6 * PROGRAMMERS: ReactOS Portable Systems Group
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 /* GLOBALS ********************************************************************/
16
17 typedef struct _IOPNP_DEVICE_EXTENSION
18 {
19 PWCHAR CompatibleIdList;
20 ULONG CompatibleIdListSize;
21 } IOPNP_DEVICE_EXTENSION, *PIOPNP_DEVICE_EXTENSION;
22
23 PUNICODE_STRING PiInitGroupOrderTable;
24 USHORT PiInitGroupOrderTableCount;
25 INTERFACE_TYPE PnpDefaultInterfaceType;
26
27 /* FUNCTIONS ******************************************************************/
28
29 INTERFACE_TYPE
30 NTAPI
31 IopDetermineDefaultInterfaceType(VOID)
32 {
33 /* FIXME: ReactOS doesn't support MicroChannel yet */
34 return Isa;
35 }
36
37 NTSTATUS
38 NTAPI
39 IopInitializeArbiters(VOID)
40 {
41 /* FIXME: TODO */
42 return STATUS_SUCCESS;
43 }
44
45 NTSTATUS
46 NTAPI
47 INIT_FUNCTION
48 PiInitCacheGroupInformation(VOID)
49 {
50 HANDLE KeyHandle;
51 NTSTATUS Status;
52 PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
53 PUNICODE_STRING GroupTable;
54 ULONG Count;
55 UNICODE_STRING GroupString =
56 RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet"
57 L"\\Control\\ServiceGroupOrder");
58
59 /* ReactOS HACK for SETUPLDR */
60 if (KeLoaderBlock->SetupLdrBlock)
61 {
62 DPRINT1("WARNING!! In PiInitCacheGroupInformation, using ReactOS HACK for SETUPLDR!!\n");
63
64 /* Bogus data */
65 PiInitGroupOrderTableCount = 0;
66 PiInitGroupOrderTable = (PVOID)0xBABEB00B;
67 return STATUS_SUCCESS;
68 }
69
70 /* Open the registry key */
71 Status = IopOpenRegistryKeyEx(&KeyHandle,
72 NULL,
73 &GroupString,
74 KEY_READ);
75 if (NT_SUCCESS(Status))
76 {
77 /* Get the list */
78 Status = IopGetRegistryValue(KeyHandle, L"List", &KeyValueInformation);
79 ZwClose(KeyHandle);
80
81 /* Make sure we got it */
82 if (NT_SUCCESS(Status))
83 {
84 /* Make sure it's valid */
85 if ((KeyValueInformation->Type == REG_MULTI_SZ) &&
86 (KeyValueInformation->DataLength))
87 {
88 /* Convert it to unicode strings */
89 Status = PnpRegMultiSzToUnicodeStrings(KeyValueInformation,
90 &GroupTable,
91 &Count);
92
93 /* Cache it for later */
94 PiInitGroupOrderTable = GroupTable;
95 PiInitGroupOrderTableCount = (USHORT)Count;
96 }
97 else
98 {
99 /* Fail */
100 Status = STATUS_UNSUCCESSFUL;
101 }
102
103 /* Free the information */
104 ExFreePool(KeyValueInformation);
105 }
106 }
107
108 /* Return status */
109 return Status;
110 }
111
112 USHORT
113 NTAPI
114 PpInitGetGroupOrderIndex(IN HANDLE ServiceHandle)
115 {
116 NTSTATUS Status;
117 PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
118 USHORT i;
119 PVOID Buffer;
120 UNICODE_STRING Group;
121 PAGED_CODE();
122
123 /* Make sure we have a cache */
124 if (!PiInitGroupOrderTable) return -1;
125
126 /* If we don't have a handle, the rest is easy -- return the count */
127 if (!ServiceHandle) return PiInitGroupOrderTableCount + 1;
128
129 /* Otherwise, get the group value */
130 Status = IopGetRegistryValue(ServiceHandle, L"Group", &KeyValueInformation);
131 if (!NT_SUCCESS(Status)) return PiInitGroupOrderTableCount;
132
133 /* Make sure we have a valid string */
134 ASSERT(KeyValueInformation->Type == REG_SZ);
135 ASSERT(KeyValueInformation->DataLength);
136
137 /* Convert to unicode string */
138 Buffer = (PVOID)((ULONG_PTR)KeyValueInformation + KeyValueInformation->DataOffset);
139 PnpRegSzToString(Buffer, KeyValueInformation->DataLength, &Group.Length);
140 Group.MaximumLength = (USHORT)KeyValueInformation->DataLength;
141 Group.Buffer = Buffer;
142
143 /* Loop the groups */
144 for (i = 0; i < PiInitGroupOrderTableCount; i++)
145 {
146 /* Try to find a match */
147 if (RtlEqualUnicodeString(&Group, &PiInitGroupOrderTable[i], TRUE)) break;
148 }
149
150 /* We're done */
151 ExFreePool(KeyValueInformation);
152 return i;
153 }
154
155 USHORT
156 NTAPI
157 PipGetDriverTagPriority(IN HANDLE ServiceHandle)
158 {
159 NTSTATUS Status;
160 HANDLE KeyHandle = NULL;
161 PKEY_VALUE_FULL_INFORMATION KeyValueInformation = NULL;
162 PKEY_VALUE_FULL_INFORMATION KeyValueInformationTag;
163 PKEY_VALUE_FULL_INFORMATION KeyValueInformationGroupOrderList;
164 PVOID Buffer;
165 UNICODE_STRING Group;
166 PULONG GroupOrder;
167 ULONG Count, Tag = 0;
168 USHORT i = -1;
169 UNICODE_STRING GroupString =
170 RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet"
171 L"\\Control\\ServiceGroupOrder");
172
173 /* Open the key */
174 Status = IopOpenRegistryKeyEx(&KeyHandle, NULL, &GroupString, KEY_READ);
175 if (!NT_SUCCESS(Status)) goto Quickie;
176
177 /* Read the group */
178 Status = IopGetRegistryValue(ServiceHandle, L"Group", &KeyValueInformation);
179 if (!NT_SUCCESS(Status)) goto Quickie;
180
181 /* Make sure we have a group */
182 if ((KeyValueInformation->Type == REG_SZ) &&
183 (KeyValueInformation->DataLength))
184 {
185 /* Convert to unicode string */
186 Buffer = (PVOID)((ULONG_PTR)KeyValueInformation + KeyValueInformation->DataOffset);
187 PnpRegSzToString(Buffer, KeyValueInformation->DataLength, &Group.Length);
188 Group.MaximumLength = (USHORT)KeyValueInformation->DataLength;
189 Group.Buffer = Buffer;
190 }
191
192 /* Now read the tag */
193 Status = IopGetRegistryValue(ServiceHandle, L"Tag", &KeyValueInformationTag);
194 if (!NT_SUCCESS(Status)) goto Quickie;
195
196 /* Make sure we have a tag */
197 if ((KeyValueInformationTag->Type == REG_DWORD) &&
198 (KeyValueInformationTag->DataLength))
199 {
200 /* Read it */
201 Tag = *(PULONG)((ULONG_PTR)KeyValueInformationTag +
202 KeyValueInformationTag->DataOffset);
203 }
204
205 /* We can get rid of this now */
206 ExFreePool(KeyValueInformationTag);
207
208 /* Now let's read the group's tag order */
209 Status = IopGetRegistryValue(KeyHandle,
210 Group.Buffer,
211 &KeyValueInformationGroupOrderList);
212
213 /* We can get rid of this now */
214 Quickie:
215 if (KeyValueInformation) ExFreePool(KeyValueInformation);
216 if (KeyHandle) NtClose(KeyHandle);
217 if (!NT_SUCCESS(Status)) return -1;
218
219 /* We're on the success path -- validate the tag order*/
220 if ((KeyValueInformationGroupOrderList->Type == REG_BINARY) &&
221 (KeyValueInformationGroupOrderList->DataLength))
222 {
223 /* Get the order array */
224 GroupOrder = (PULONG)((ULONG_PTR)KeyValueInformationGroupOrderList +
225 KeyValueInformationGroupOrderList->DataOffset);
226
227 /* Get the count */
228 Count = *GroupOrder;
229 ASSERT(((Count + 1) * sizeof(ULONG)) <=
230 KeyValueInformationGroupOrderList->DataLength);
231
232 /* Now loop each tag */
233 GroupOrder++;
234 for (i = 1; i <= Count; i++)
235 {
236 /* If we found it, we're out */
237 if (Tag == *GroupOrder) break;
238
239 /* Try the next one */
240 GroupOrder++;
241 }
242 }
243
244 /* Last buffer to free */
245 ExFreePool(KeyValueInformationGroupOrderList);
246 return i;
247 }
248
249 NTSTATUS
250 NTAPI
251 PipCallDriverAddDevice(IN PDEVICE_NODE DeviceNode,
252 IN BOOLEAN LoadDriver,
253 IN PDRIVER_OBJECT DriverObject)
254 {
255 NTSTATUS Status;
256 HANDLE EnumRootKey, SubKey, ControlKey, ClassKey, PropertiesKey;
257 UNICODE_STRING ClassGuid, Properties;
258 UNICODE_STRING EnumRoot = RTL_CONSTANT_STRING(ENUM_ROOT);
259 UNICODE_STRING ControlClass =
260 RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Class");
261 PKEY_VALUE_FULL_INFORMATION KeyValueInformation = NULL;
262 PWCHAR Buffer;
263
264 /* Open enumeration root key */
265 Status = IopOpenRegistryKeyEx(&EnumRootKey,
266 NULL,
267 &EnumRoot,
268 KEY_READ);
269 if (!NT_SUCCESS(Status))
270 {
271 DPRINT1("IopOpenRegistryKeyEx() failed with Status %08X\n", Status);
272 return Status;
273 }
274
275 /* Open instance subkey */
276 Status = IopOpenRegistryKeyEx(&SubKey,
277 EnumRootKey,
278 &DeviceNode->InstancePath,
279 KEY_READ);
280 ZwClose(EnumRootKey);
281 if (!NT_SUCCESS(Status))
282 {
283 DPRINT1("IopOpenRegistryKeyEx() failed with Status %08X\n", Status);
284 return Status;
285 }
286
287 /* Get class GUID */
288 Status = IopGetRegistryValue(SubKey,
289 REGSTR_VAL_CLASSGUID,
290 &KeyValueInformation);
291 if (NT_SUCCESS(Status))
292 {
293 /* Convert to unicode string */
294 Buffer = (PVOID)((ULONG_PTR)KeyValueInformation + KeyValueInformation->DataOffset);
295 PnpRegSzToString(Buffer, KeyValueInformation->DataLength, &ClassGuid.Length);
296 ClassGuid.MaximumLength = (USHORT)KeyValueInformation->DataLength;
297 ClassGuid.Buffer = Buffer;
298
299 /* Open the key */
300 Status = IopOpenRegistryKeyEx(&ControlKey,
301 NULL,
302 &ControlClass,
303 KEY_READ);
304 if (!NT_SUCCESS(Status))
305 {
306 /* No class key */
307 DPRINT1("IopOpenRegistryKeyEx() failed with Status %08X\n", Status);
308 ClassKey = NULL;
309 }
310 else
311 {
312 /* Open the class key */
313 Status = IopOpenRegistryKeyEx(&ClassKey,
314 ControlKey,
315 &ClassGuid,
316 KEY_READ);
317 ZwClose(ControlKey);
318 if (!NT_SUCCESS(Status))
319 {
320 /* No class key */
321 DPRINT1("IopOpenRegistryKeyEx() failed with Status %08X\n", Status);
322 ClassKey = NULL;
323 }
324 }
325
326 /* Check if we made it till here */
327 if (ClassKey)
328 {
329 /* Get the device properties */
330 RtlInitUnicodeString(&Properties, REGSTR_KEY_DEVICE_PROPERTIES);
331 Status = IopOpenRegistryKeyEx(&PropertiesKey,
332 ClassKey,
333 &Properties,
334 KEY_READ);
335 ZwClose(ClassKey);
336 if (!NT_SUCCESS(Status))
337 {
338 /* No properties */
339 DPRINT("IopOpenRegistryKeyEx() failed with Status %08X\n", Status);
340 PropertiesKey = NULL;
341 }
342 else
343 {
344 ZwClose(PropertiesKey);
345 }
346 }
347
348 /* Free the registry data */
349 ExFreePool(KeyValueInformation);
350 }
351
352 /* Do ReactOS-style setup */
353 Status = IopAttachFilterDrivers(DeviceNode, TRUE);
354 if (!NT_SUCCESS(Status))
355 {
356 IopRemoveDevice(DeviceNode);
357 return Status;
358 }
359 Status = IopInitializeDevice(DeviceNode, DriverObject);
360 if (NT_SUCCESS(Status))
361 {
362 Status = IopAttachFilterDrivers(DeviceNode, FALSE);
363 if (!NT_SUCCESS(Status))
364 {
365 IopRemoveDevice(DeviceNode);
366 return Status;
367 }
368
369 Status = IopStartDevice(DeviceNode);
370 }
371
372 /* Return status */
373 return Status;
374 }
375
376 NTSTATUS
377 NTAPI
378 INIT_FUNCTION
379 IopInitializePlugPlayServices(VOID)
380 {
381 NTSTATUS Status;
382 ULONG Disposition;
383 HANDLE KeyHandle, EnumHandle, ParentHandle, TreeHandle, ControlHandle;
384 UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET");
385 UNICODE_STRING PnpManagerDriverName = RTL_CONSTANT_STRING(DRIVER_ROOT_NAME L"PnpManager");
386 PDEVICE_OBJECT Pdo;
387
388 /* Initialize locks and such */
389 KeInitializeSpinLock(&IopDeviceTreeLock);
390 KeInitializeSpinLock(&IopDeviceRelationsSpinLock);
391 InitializeListHead(&IopDeviceRelationsRequestList);
392
393 /* Get the default interface */
394 PnpDefaultInterfaceType = IopDetermineDefaultInterfaceType();
395
396 /* Initialize arbiters */
397 Status = IopInitializeArbiters();
398 if (!NT_SUCCESS(Status)) return Status;
399
400 /* Setup the group cache */
401 Status = PiInitCacheGroupInformation();
402 if (!NT_SUCCESS(Status)) return Status;
403
404 /* Open the current control set */
405 Status = IopOpenRegistryKeyEx(&KeyHandle,
406 NULL,
407 &KeyName,
408 KEY_ALL_ACCESS);
409 if (!NT_SUCCESS(Status)) return Status;
410
411 /* Create the control key */
412 RtlInitUnicodeString(&KeyName, L"Control");
413 Status = IopCreateRegistryKeyEx(&ControlHandle,
414 KeyHandle,
415 &KeyName,
416 KEY_ALL_ACCESS,
417 REG_OPTION_NON_VOLATILE,
418 &Disposition);
419 if (!NT_SUCCESS(Status)) return Status;
420
421 /* Check if it's a new key */
422 if (Disposition == REG_CREATED_NEW_KEY)
423 {
424 HANDLE DeviceClassesHandle;
425
426 /* Create the device classes key */
427 RtlInitUnicodeString(&KeyName, L"DeviceClasses");
428 Status = IopCreateRegistryKeyEx(&DeviceClassesHandle,
429 ControlHandle,
430 &KeyName,
431 KEY_ALL_ACCESS,
432 REG_OPTION_NON_VOLATILE,
433 &Disposition);
434 if (!NT_SUCCESS(Status)) return Status;
435
436 ZwClose(DeviceClassesHandle);
437 }
438
439 ZwClose(ControlHandle);
440
441 /* Create the enum key */
442 RtlInitUnicodeString(&KeyName, REGSTR_KEY_ENUM);
443 Status = IopCreateRegistryKeyEx(&EnumHandle,
444 KeyHandle,
445 &KeyName,
446 KEY_ALL_ACCESS,
447 REG_OPTION_NON_VOLATILE,
448 &Disposition);
449 if (!NT_SUCCESS(Status)) return Status;
450
451 /* Check if it's a new key */
452 if (Disposition == REG_CREATED_NEW_KEY)
453 {
454 /* FIXME: DACLs */
455 }
456
457 /* Create the root key */
458 ParentHandle = EnumHandle;
459 RtlInitUnicodeString(&KeyName, REGSTR_KEY_ROOTENUM);
460 Status = IopCreateRegistryKeyEx(&EnumHandle,
461 ParentHandle,
462 &KeyName,
463 KEY_ALL_ACCESS,
464 REG_OPTION_NON_VOLATILE,
465 &Disposition);
466 NtClose(ParentHandle);
467 if (!NT_SUCCESS(Status)) return Status;
468 NtClose(EnumHandle);
469
470 /* Open the root key now */
471 RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET\\ENUM");
472 Status = IopOpenRegistryKeyEx(&EnumHandle,
473 NULL,
474 &KeyName,
475 KEY_ALL_ACCESS);
476 if (NT_SUCCESS(Status))
477 {
478 /* Create the root dev node */
479 RtlInitUnicodeString(&KeyName, REGSTR_VAL_ROOT_DEVNODE);
480 Status = IopCreateRegistryKeyEx(&TreeHandle,
481 EnumHandle,
482 &KeyName,
483 KEY_ALL_ACCESS,
484 REG_OPTION_NON_VOLATILE,
485 NULL);
486 NtClose(EnumHandle);
487 if (NT_SUCCESS(Status)) NtClose(TreeHandle);
488 }
489
490 /* Create the root driver */
491 Status = IoCreateDriver(&PnpManagerDriverName, PnpRootDriverEntry);
492 if (!NT_SUCCESS(Status))
493 {
494 DPRINT1("IoCreateDriverObject() failed\n");
495 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
496 }
497
498 /* Create the root PDO */
499 Status = IoCreateDevice(IopRootDriverObject,
500 sizeof(IOPNP_DEVICE_EXTENSION),
501 NULL,
502 FILE_DEVICE_CONTROLLER,
503 0,
504 FALSE,
505 &Pdo);
506 if (!NT_SUCCESS(Status))
507 {
508 DPRINT1("IoCreateDevice() failed\n");
509 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
510 }
511
512 /* This is a bus enumerated device */
513 Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
514
515 /* Create the root device node */
516 IopRootDeviceNode = PipAllocateDeviceNode(Pdo);
517
518 /* Set flags */
519 IopRootDeviceNode->Flags |= DNF_STARTED + DNF_PROCESSED + DNF_ENUMERATED +
520 DNF_MADEUP + DNF_NO_RESOURCE_REQUIRED +
521 DNF_ADDED;
522
523 /* Create instance path */
524 RtlCreateUnicodeString(&IopRootDeviceNode->InstancePath,
525 REGSTR_VAL_ROOT_DEVNODE);
526
527 /* Call the add device routine */
528 IopRootDriverObject->DriverExtension->AddDevice(IopRootDriverObject,
529 IopRootDeviceNode->PhysicalDeviceObject);
530
531 /* Initialize PnP-Event notification support */
532 Status = IopInitPlugPlayEvents();
533 if (!NT_SUCCESS(Status)) return Status;
534
535 /* Report the device to the user-mode pnp manager */
536 IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
537 &IopRootDeviceNode->InstancePath);
538
539 /* Initialize the Bus Type GUID List */
540 PnpBusTypeGuidList = ExAllocatePool(PagedPool, sizeof(IO_BUS_TYPE_GUID_LIST));
541 RtlZeroMemory(PnpBusTypeGuidList, sizeof(IO_BUS_TYPE_GUID_LIST));
542 ExInitializeFastMutex(&PnpBusTypeGuidList->Lock);
543
544 /* Launch the firmware mapper */
545 Status = IopUpdateRootKey();
546 if (!NT_SUCCESS(Status)) return Status;
547
548 /* Close the handle to the control set */
549 NtClose(KeyHandle);
550
551 /* We made it */
552 return STATUS_SUCCESS;
553 }
554
555 /* EOF */