* Sync with recent trunk (r52637).
[reactos.git] / ntoskrnl / io / pnpmgr / pnpreport.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * COPYRIGHT: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/io/pnpmgr/pnpreport.c
5 * PURPOSE: Device Changes Reporting Functions
6 * PROGRAMMERS: Cameron Gutman (cameron.gutman@reactos.org)
7 * Pierre Schweitzer
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <debug.h>
15
16 /* TYPES *******************************************************************/
17
18 typedef struct _INTERNAL_WORK_QUEUE_ITEM
19 {
20 WORK_QUEUE_ITEM WorkItem;
21 PDEVICE_OBJECT PhysicalDeviceObject;
22 PDEVICE_CHANGE_COMPLETE_CALLBACK Callback;
23 PVOID Context;
24 PTARGET_DEVICE_CUSTOM_NOTIFICATION NotificationStructure;
25 } INTERNAL_WORK_QUEUE_ITEM, *PINTERNAL_WORK_QUEUE_ITEM;
26
27 NTSTATUS
28 NTAPI
29 IopCreateDeviceKeyPath(IN PCUNICODE_STRING RegistryPath,
30 IN ULONG CreateOptions,
31 OUT PHANDLE Handle);
32
33 NTSTATUS
34 IopSetDeviceInstanceData(HANDLE InstanceKey,
35 PDEVICE_NODE DeviceNode);
36
37 NTSTATUS
38 IopActionInterrogateDeviceStack(PDEVICE_NODE DeviceNode,
39 PVOID Context);
40
41 NTSTATUS
42 PpSetCustomTargetEvent(IN PDEVICE_OBJECT DeviceObject,
43 IN OUT PKEVENT SyncEvent OPTIONAL,
44 IN OUT PNTSTATUS SyncStatus OPTIONAL,
45 IN PDEVICE_CHANGE_COMPLETE_CALLBACK Callback OPTIONAL,
46 IN PVOID Context OPTIONAL,
47 IN PTARGET_DEVICE_CUSTOM_NOTIFICATION NotificationStructure);
48
49 /* PRIVATE FUNCTIONS *********************************************************/
50
51 PWCHAR
52 IopGetInterfaceTypeString(INTERFACE_TYPE IfType)
53 {
54 switch (IfType)
55 {
56 case Internal:
57 return L"Internal";
58
59 case Isa:
60 return L"Isa";
61
62 case Eisa:
63 return L"Eisa";
64
65 case MicroChannel:
66 return L"MicroChannel";
67
68 case TurboChannel:
69 return L"TurboChannel";
70
71 case PCIBus:
72 return L"PCIBus";
73
74 case VMEBus:
75 return L"VMEBus";
76
77 case NuBus:
78 return L"NuBus";
79
80 case PCMCIABus:
81 return L"PCMCIABus";
82
83 case CBus:
84 return L"CBus";
85
86 case MPIBus:
87 return L"MPIBus";
88
89 case MPSABus:
90 return L"MPSABus";
91
92 case ProcessorInternal:
93 return L"ProcessorInternal";
94
95 case PNPISABus:
96 return L"PNPISABus";
97
98 case PNPBus:
99 return L"PNPBus";
100
101 case Vmcs:
102 return L"Vmcs";
103
104 default:
105 DPRINT1("Invalid bus type: %d\n", IfType);
106 return NULL;
107 }
108 }
109
110 VOID
111 IopReportTargetDeviceChangeAsyncWorker(PVOID Context)
112 {
113 PINTERNAL_WORK_QUEUE_ITEM Item;
114
115 Item = (PINTERNAL_WORK_QUEUE_ITEM)Context;
116 PpSetCustomTargetEvent(Item->PhysicalDeviceObject, NULL, NULL, Item->Callback, Item->Context, Item->NotificationStructure);
117 ObDereferenceObject(Item->PhysicalDeviceObject);
118 ExFreePoolWithTag(Context, ' pP');
119 }
120
121 NTSTATUS
122 PpSetCustomTargetEvent(IN PDEVICE_OBJECT DeviceObject,
123 IN OUT PKEVENT SyncEvent OPTIONAL,
124 IN OUT PNTSTATUS SyncStatus OPTIONAL,
125 IN PDEVICE_CHANGE_COMPLETE_CALLBACK Callback OPTIONAL,
126 IN PVOID Context OPTIONAL,
127 IN PTARGET_DEVICE_CUSTOM_NOTIFICATION NotificationStructure)
128 {
129 ASSERT(NotificationStructure != NULL);
130 ASSERT(DeviceObject != NULL);
131
132 if (SyncEvent)
133 {
134 ASSERT(SyncStatus);
135 *SyncStatus = STATUS_PENDING;
136 }
137
138 /* That call is totally wrong but notifications handler must be fixed first */
139 IopNotifyPlugPlayNotification(DeviceObject,
140 EventCategoryTargetDeviceChange,
141 &GUID_PNP_CUSTOM_NOTIFICATION,
142 NotificationStructure,
143 NULL);
144
145 if (SyncEvent)
146 {
147 KeSetEvent(SyncEvent, IO_NO_INCREMENT, FALSE);
148 *SyncStatus = STATUS_SUCCESS;
149 }
150
151 return STATUS_SUCCESS;
152 }
153
154 /* PUBLIC FUNCTIONS **********************************************************/
155
156 /*
157 * @implemented
158 */
159 NTSTATUS
160 NTAPI
161 IoReportDetectedDevice(IN PDRIVER_OBJECT DriverObject,
162 IN INTERFACE_TYPE LegacyBusType,
163 IN ULONG BusNumber,
164 IN ULONG SlotNumber,
165 IN PCM_RESOURCE_LIST ResourceList,
166 IN PIO_RESOURCE_REQUIREMENTS_LIST ResourceRequirements OPTIONAL,
167 IN BOOLEAN ResourceAssigned,
168 IN OUT PDEVICE_OBJECT *DeviceObject OPTIONAL)
169 {
170 PDEVICE_NODE DeviceNode;
171 PDEVICE_OBJECT Pdo;
172 NTSTATUS Status;
173 HANDLE InstanceKey;
174 ULONG RequiredLength;
175 UNICODE_STRING ValueName, ServiceName;
176 WCHAR HardwareId[256];
177 PWCHAR IfString;
178 ULONG IdLength;
179
180 DPRINT("IoReportDetectedDevice (DeviceObject %p, *DeviceObject %p)\n",
181 DeviceObject, DeviceObject ? *DeviceObject : NULL);
182
183 /* Create the service name (eg. ACPI_HAL) */
184 ServiceName.Buffer = DriverObject->DriverName.Buffer +
185 sizeof(DRIVER_ROOT_NAME) / sizeof(WCHAR) - 1;
186 ServiceName.Length = DriverObject->DriverName.Length -
187 sizeof(DRIVER_ROOT_NAME) + sizeof(WCHAR);
188 ServiceName.MaximumLength = ServiceName.Length;
189
190 /* If the interface type is unknown, treat it as internal */
191 if (LegacyBusType == InterfaceTypeUndefined)
192 LegacyBusType = Internal;
193
194 /* Get the string equivalent of the interface type */
195 IfString = IopGetInterfaceTypeString(LegacyBusType);
196
197 /* If NULL is returned then it's a bad type */
198 if (!IfString)
199 return STATUS_INVALID_PARAMETER;
200
201 /* We use the caller's PDO if they supplied one */
202 if (DeviceObject && *DeviceObject)
203 {
204 Pdo = *DeviceObject;
205 DeviceNode = IopGetDeviceNode(*DeviceObject);
206 }
207 else
208 {
209 /* Create the PDO */
210 Status = PnpRootCreateDevice(&ServiceName,
211 &Pdo,
212 NULL);
213 if (!NT_SUCCESS(Status))
214 {
215 DPRINT("PnpRootCreateDevice() failed (Status 0x%08lx)\n", Status);
216 return Status;
217 }
218
219 /* Create the device node for the new PDO */
220 Status = IopCreateDeviceNode(IopRootDeviceNode,
221 Pdo,
222 NULL,
223 &DeviceNode);
224
225 if (!NT_SUCCESS(Status))
226 {
227 DPRINT("IopCreateDeviceNode() failed (Status 0x%08lx)\n", Status);
228 return Status;
229 }
230 }
231
232 /* We don't call AddDevice for devices reported this way */
233 IopDeviceNodeSetFlag(DeviceNode, DNF_ADDED);
234
235 /* We don't send IRP_MN_START_DEVICE */
236 IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
237
238 /* We need to get device IDs */
239 #if 0
240 IopDeviceNodeSetFlag(DeviceNode, DNF_NEED_QUERY_IDS);
241 #endif
242
243 /* This is a legacy driver for this device */
244 IopDeviceNodeSetFlag(DeviceNode, DNF_LEGACY_DRIVER);
245
246 /* Perform a manual configuration of our device */
247 IopActionInterrogateDeviceStack(DeviceNode, DeviceNode->Parent);
248 IopActionConfigureChildServices(DeviceNode, DeviceNode->Parent);
249
250 /* Open a handle to the instance path key */
251 Status = IopCreateDeviceKeyPath(&DeviceNode->InstancePath, 0, &InstanceKey);
252 if (!NT_SUCCESS(Status))
253 return Status;
254
255 /* Add DETECTEDInterfaceType\DriverName */
256 IdLength = 0;
257 IdLength += swprintf(&HardwareId[IdLength],
258 L"DETECTED%ls\\%wZ",
259 IfString,
260 &ServiceName);
261 HardwareId[IdLength++] = UNICODE_NULL;
262
263 /* Add DETECTED\DriverName */
264 IdLength += swprintf(&HardwareId[IdLength],
265 L"DETECTED\\%wZ",
266 &ServiceName);
267 HardwareId[IdLength++] = UNICODE_NULL;
268
269 /* Terminate the string with another null */
270 HardwareId[IdLength] = UNICODE_NULL;
271
272 /* Store the value for CompatibleIDs */
273 RtlInitUnicodeString(&ValueName, L"CompatibleIDs");
274 Status = ZwSetValueKey(InstanceKey, &ValueName, 0, REG_MULTI_SZ, HardwareId, IdLength * sizeof(WCHAR));
275 if (!NT_SUCCESS(Status))
276 {
277 DPRINT("Failed to write the compatible IDs: 0x%x\n", Status);
278 ZwClose(InstanceKey);
279 return Status;
280 }
281
282 /* Add a hardware ID if the driver didn't report one */
283 RtlInitUnicodeString(&ValueName, L"HardwareID");
284 if (ZwQueryValueKey(InstanceKey, &ValueName, KeyValueBasicInformation, NULL, 0, &RequiredLength) == STATUS_OBJECT_NAME_NOT_FOUND)
285 {
286 /* Just use our most specific compatible ID */
287 IdLength = 0;
288 IdLength += swprintf(&HardwareId[IdLength],
289 L"DETECTED%ls\\%wZ",
290 IfString,
291 &ServiceName);
292 HardwareId[++IdLength] = UNICODE_NULL;
293
294 /* Write the value to the registry */
295 Status = ZwSetValueKey(InstanceKey, &ValueName, 0, REG_SZ, HardwareId, IdLength * sizeof(WCHAR));
296 if (!NT_SUCCESS(Status))
297 {
298 DPRINT("Failed to write the hardware ID: 0x%x\n", Status);
299 ZwClose(InstanceKey);
300 return Status;
301 }
302 }
303
304 /* Assign the resources to the device node */
305 DeviceNode->BootResources = ResourceList;
306 DeviceNode->ResourceRequirements = ResourceRequirements;
307
308 /* Set appropriate flags */
309 if (DeviceNode->BootResources)
310 IopDeviceNodeSetFlag(DeviceNode, DNF_HAS_BOOT_CONFIG);
311
312 if (!DeviceNode->ResourceRequirements && !DeviceNode->BootResources)
313 IopDeviceNodeSetFlag(DeviceNode, DNF_NO_RESOURCE_REQUIRED);
314
315 /* Write the resource information to the registry */
316 IopSetDeviceInstanceData(InstanceKey, DeviceNode);
317
318 /* If the caller didn't get the resources assigned for us, do it now */
319 if (!ResourceAssigned)
320 {
321 Status = IopAssignDeviceResources(DeviceNode);
322
323 /* See if we failed */
324 if (!NT_SUCCESS(Status))
325 {
326 DPRINT("Assigning resources failed: 0x%x\n", Status);
327 ZwClose(InstanceKey);
328 return Status;
329 }
330 }
331
332 /* Close the instance key handle */
333 ZwClose(InstanceKey);
334
335 /* Report the device's enumeration to umpnpmgr */
336 IopQueueTargetDeviceEvent(&GUID_DEVICE_ENUMERATED,
337 &DeviceNode->InstancePath);
338
339 /* Report the device's arrival to umpnpmgr */
340 IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
341 &DeviceNode->InstancePath);
342
343 DPRINT1("Reported device: %S (%wZ)\n", HardwareId, &DeviceNode->InstancePath);
344
345 /* Return the PDO */
346 if (DeviceObject) *DeviceObject = Pdo;
347
348 return STATUS_SUCCESS;
349 }
350
351 /*
352 * @halfplemented
353 */
354 NTSTATUS
355 NTAPI
356 IoReportResourceForDetection(IN PDRIVER_OBJECT DriverObject,
357 IN PCM_RESOURCE_LIST DriverList OPTIONAL,
358 IN ULONG DriverListSize OPTIONAL,
359 IN PDEVICE_OBJECT DeviceObject OPTIONAL,
360 IN PCM_RESOURCE_LIST DeviceList OPTIONAL,
361 IN ULONG DeviceListSize OPTIONAL,
362 OUT PBOOLEAN ConflictDetected)
363 {
364 PCM_RESOURCE_LIST ResourceList;
365 NTSTATUS Status;
366
367 *ConflictDetected = FALSE;
368
369 if (!DriverList && !DeviceList)
370 return STATUS_INVALID_PARAMETER;
371
372 /* Find the real list */
373 if (!DriverList)
374 ResourceList = DeviceList;
375 else
376 ResourceList = DriverList;
377
378 /* Look for a resource conflict */
379 Status = IopDetectResourceConflict(ResourceList, FALSE, NULL);
380 if (Status == STATUS_CONFLICTING_ADDRESSES)
381 {
382 /* Oh noes */
383 *ConflictDetected = TRUE;
384 }
385 else if (NT_SUCCESS(Status))
386 {
387 /* Looks like we're good to go */
388
389 /* TODO: Claim the resources in the ResourceMap */
390 }
391
392 return Status;
393 }
394
395 VOID
396 NTAPI
397 IopSetEvent(IN PVOID Context)
398 {
399 PKEVENT Event = Context;
400
401 /* Set the event */
402 KeSetEvent(Event, IO_NO_INCREMENT, FALSE);
403 }
404
405 /*
406 * @implemented
407 */
408 NTSTATUS
409 NTAPI
410 IoReportTargetDeviceChange(IN PDEVICE_OBJECT PhysicalDeviceObject,
411 IN PVOID NotificationStructure)
412 {
413 KEVENT NotifyEvent;
414 NTSTATUS Status, NotifyStatus;
415 PTARGET_DEVICE_CUSTOM_NOTIFICATION notifyStruct = (PTARGET_DEVICE_CUSTOM_NOTIFICATION)NotificationStructure;
416
417 ASSERT(notifyStruct);
418
419 /* Check for valid PDO */
420 if (!IopIsValidPhysicalDeviceObject(PhysicalDeviceObject))
421 {
422 KeBugCheckEx(PNP_DETECTED_FATAL_ERROR, 0x2, (ULONG)PhysicalDeviceObject, 0, 0);
423 }
424
425 /* FileObject must be null. PnP will fill in it */
426 ASSERT(notifyStruct->FileObject == NULL);
427
428 /* Do not handle system PnP events */
429 if ((RtlCompareMemory(&(notifyStruct->Event), &(GUID_TARGET_DEVICE_QUERY_REMOVE), sizeof(GUID)) != sizeof(GUID)) ||
430 (RtlCompareMemory(&(notifyStruct->Event), &(GUID_TARGET_DEVICE_REMOVE_CANCELLED), sizeof(GUID)) != sizeof(GUID)) ||
431 (RtlCompareMemory(&(notifyStruct->Event), &(GUID_TARGET_DEVICE_REMOVE_COMPLETE), sizeof(GUID)) != sizeof(GUID)))
432 {
433 return STATUS_INVALID_DEVICE_REQUEST;
434 }
435
436 if (notifyStruct->Version != 1)
437 {
438 return STATUS_INVALID_DEVICE_REQUEST;
439 }
440
441 /* Initialize even that will let us know when PnP will have finished notify */
442 KeInitializeEvent(&NotifyEvent, NotificationEvent, FALSE);
443
444 Status = PpSetCustomTargetEvent(PhysicalDeviceObject, &NotifyEvent, &NotifyStatus, NULL, NULL, notifyStruct);
445 /* If no error, wait for the notify to end and return the status of the notify and not of the event */
446 if (NT_SUCCESS(Status))
447 {
448 KeWaitForSingleObject(&NotifyEvent, Executive, KernelMode, FALSE, NULL);
449 Status = NotifyStatus;
450 }
451
452 return Status;
453 }
454
455 /*
456 * @implemented
457 */
458 NTSTATUS
459 NTAPI
460 IoReportTargetDeviceChangeAsynchronous(IN PDEVICE_OBJECT PhysicalDeviceObject,
461 IN PVOID NotificationStructure,
462 IN PDEVICE_CHANGE_COMPLETE_CALLBACK Callback OPTIONAL,
463 IN PVOID Context OPTIONAL)
464 {
465 PINTERNAL_WORK_QUEUE_ITEM Item = NULL;
466 PTARGET_DEVICE_CUSTOM_NOTIFICATION notifyStruct = (PTARGET_DEVICE_CUSTOM_NOTIFICATION)NotificationStructure;
467
468 ASSERT(notifyStruct);
469
470 /* Check for valid PDO */
471 if (!IopIsValidPhysicalDeviceObject(PhysicalDeviceObject))
472 {
473 KeBugCheckEx(PNP_DETECTED_FATAL_ERROR, 0x2, (ULONG)PhysicalDeviceObject, 0, 0);
474 }
475
476 /* FileObject must be null. PnP will fill in it */
477 ASSERT(notifyStruct->FileObject == NULL);
478
479 /* Do not handle system PnP events */
480 if ((RtlCompareMemory(&(notifyStruct->Event), &(GUID_TARGET_DEVICE_QUERY_REMOVE), sizeof(GUID)) != sizeof(GUID)) ||
481 (RtlCompareMemory(&(notifyStruct->Event), &(GUID_TARGET_DEVICE_REMOVE_CANCELLED), sizeof(GUID)) != sizeof(GUID)) ||
482 (RtlCompareMemory(&(notifyStruct->Event), &(GUID_TARGET_DEVICE_REMOVE_COMPLETE), sizeof(GUID)) != sizeof(GUID)))
483 {
484 return STATUS_INVALID_DEVICE_REQUEST;
485 }
486
487 if (notifyStruct->Version != 1)
488 {
489 return STATUS_INVALID_DEVICE_REQUEST;
490 }
491
492 /* We need to store all the data given by the caller with the WorkItem, so use our own struct */
493 Item = ExAllocatePoolWithTag(NonPagedPool, sizeof(INTERNAL_WORK_QUEUE_ITEM), ' pP');
494 if (!Item) return STATUS_INSUFFICIENT_RESOURCES;
495
496 /* Initialize all stuff */
497 ObReferenceObject(PhysicalDeviceObject);
498 Item->NotificationStructure = notifyStruct;
499 Item->PhysicalDeviceObject = PhysicalDeviceObject;
500 Item->Callback = Callback;
501 Item->Context = Context;
502 ExInitializeWorkItem(&(Item->WorkItem), (PWORKER_THREAD_ROUTINE)IopReportTargetDeviceChangeAsyncWorker, Item);
503
504 /* Finally, queue the item, our work here is done */
505 ExQueueWorkItem(&(Item->WorkItem), DelayedWorkQueue);
506
507 return STATUS_PENDING;
508 }