e6982d220009e6a9b375ddaae9827b1f8ea2df9a
[reactos.git] / reactos / drivers / video / videoprt / dispatch.c
1 /*
2 * VideoPort driver
3 *
4 * Copyright (C) 2002, 2003, 2004 ReactOS Team
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Library General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Library General Public License for more details.
15 *
16 * You should have received a copy of the GNU Library General Public
17 * License along with this library; see the file COPYING.LIB.
18 * If not, write to the Free Software Foundation,
19 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 *
21 * $Id$
22 */
23
24 #include "videoprt.h"
25
26 /* EXTERNAL FUNCTIONS *********************************************************/
27
28 VOID NTAPI HalAcquireDisplayOwnership(IN PHAL_RESET_DISPLAY_PARAMETERS ResetDisplayParameters);
29 VOID NTAPI HalReleaseDisplayOwnership();
30
31 /* GLOBAL VARIABLES ***********************************************************/
32
33 PVIDEO_PORT_DEVICE_EXTENSION ResetDisplayParametersDeviceExtension = NULL;
34
35 /* PRIVATE FUNCTIONS **********************************************************/
36
37 /*
38 * Reset display to blue screen
39 */
40
41 BOOLEAN NTAPI
42 IntVideoPortResetDisplayParameters(ULONG Columns, ULONG Rows)
43 {
44 PVIDEO_PORT_DRIVER_EXTENSION DriverExtension;
45
46 if (ResetDisplayParametersDeviceExtension == NULL)
47 return FALSE;
48
49 DriverExtension = ResetDisplayParametersDeviceExtension->DriverExtension;
50
51 if (DriverExtension->InitializationData.HwResetHw != NULL)
52 {
53 if (DriverExtension->InitializationData.HwResetHw(
54 &ResetDisplayParametersDeviceExtension->MiniPortDeviceExtension,
55 Columns, Rows))
56 {
57 ResetDisplayParametersDeviceExtension = NULL;
58 return TRUE;
59 }
60 }
61
62 ResetDisplayParametersDeviceExtension = NULL;
63 return FALSE;
64 }
65
66 NTSTATUS NTAPI
67 IntVideoPortAddDevice(
68 IN PDRIVER_OBJECT DriverObject,
69 IN PDEVICE_OBJECT PhysicalDeviceObject)
70 {
71 PVIDEO_PORT_DRIVER_EXTENSION DriverExtension;
72
73 /*
74 * Get the initialization data we saved in VideoPortInitialize.
75 */
76
77 DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
78
79 /*
80 * Create adapter device object.
81 */
82
83 return IntVideoPortCreateAdapterDeviceObject(
84 DriverObject,
85 DriverExtension,
86 PhysicalDeviceObject,
87 NULL);
88 }
89
90 /*
91 * IntVideoPortDispatchOpen
92 *
93 * Answer requests for Open calls.
94 *
95 * Run Level
96 * PASSIVE_LEVEL
97 */
98
99 NTSTATUS NTAPI
100 IntVideoPortDispatchOpen(
101 IN PDEVICE_OBJECT DeviceObject,
102 IN PIRP Irp)
103 {
104 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
105 PVIDEO_PORT_DRIVER_EXTENSION DriverExtension;
106
107 DPRINT("IntVideoPortDispatchOpen\n");
108
109 if (CsrssInitialized == FALSE)
110 {
111 /*
112 * We know the first open call will be from the CSRSS process
113 * to let us know its handle.
114 */
115
116 DPRINT("Referencing CSRSS\n");
117 Csrss = (PKPROCESS)PsGetCurrentProcess();
118 DPRINT("Csrss %p\n", Csrss);
119
120 CsrssInitialized = TRUE;
121
122 Irp->IoStatus.Information = FILE_OPENED;
123 IoCompleteRequest(Irp, IO_NO_INCREMENT);
124
125 return STATUS_SUCCESS;
126 }
127
128 DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
129 DriverExtension = DeviceExtension->DriverExtension;
130
131 if (DriverExtension->InitializationData.HwInitialize(&DeviceExtension->MiniPortDeviceExtension))
132 {
133 Irp->IoStatus.Status = STATUS_SUCCESS;
134
135 InterlockedIncrement((PLONG)&DeviceExtension->DeviceOpened);
136
137 /*
138 * Storing the device extension pointer in a static variable is an
139 * ugly hack. Unfortunately, we need it in VideoPortResetDisplayParameters
140 * and HalAcquireDisplayOwnership doesn't allow us to pass a userdata
141 * parameter. On the bright side, the DISPLAY device is opened
142 * exclusively, so there can be only one device extension active at
143 * any point in time.
144 */
145
146 ResetDisplayParametersDeviceExtension = DeviceExtension;
147 HalAcquireDisplayOwnership(IntVideoPortResetDisplayParameters);
148 }
149 else
150 {
151 Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
152 }
153
154 Irp->IoStatus.Information = FILE_OPENED;
155 IoCompleteRequest(Irp, IO_NO_INCREMENT);
156
157 return STATUS_SUCCESS;
158 }
159
160 /*
161 * IntVideoPortDispatchClose
162 *
163 * Answer requests for Close calls.
164 *
165 * Run Level
166 * PASSIVE_LEVEL
167 */
168
169 NTSTATUS NTAPI
170 IntVideoPortDispatchClose(
171 IN PDEVICE_OBJECT DeviceObject,
172 IN PIRP Irp)
173 {
174 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
175
176 DPRINT("IntVideoPortDispatchClose\n");
177
178 DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
179 if (DeviceExtension->DeviceOpened >= 1 &&
180 InterlockedDecrement((PLONG)&DeviceExtension->DeviceOpened) == 0)
181 {
182 ResetDisplayParametersDeviceExtension = DeviceExtension;
183 HalReleaseDisplayOwnership();
184 }
185
186 Irp->IoStatus.Status = STATUS_SUCCESS;
187 IoCompleteRequest(Irp, IO_NO_INCREMENT);
188
189 return STATUS_SUCCESS;
190 }
191
192 /*
193 * IntVideoPortDispatchDeviceControl
194 *
195 * Answer requests for device control calls.
196 *
197 * Run Level
198 * PASSIVE_LEVEL
199 */
200
201 NTSTATUS NTAPI
202 IntVideoPortDispatchDeviceControl(
203 IN PDEVICE_OBJECT DeviceObject,
204 IN PIRP Irp)
205 {
206 PIO_STACK_LOCATION IrpStack;
207 PVIDEO_PORT_DRIVER_EXTENSION DriverExtension;
208 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
209 PVIDEO_REQUEST_PACKET vrp;
210 NTSTATUS Status;
211
212 DPRINT("IntVideoPortDispatchDeviceControl\n");
213
214 IrpStack = IoGetCurrentIrpStackLocation(Irp);
215 DeviceExtension = DeviceObject->DeviceExtension;
216 DriverExtension = DeviceExtension->DriverExtension;
217
218 /* Translate the IRP to a VRP */
219 vrp = ExAllocatePool(NonPagedPool, sizeof(VIDEO_REQUEST_PACKET));
220 if (NULL == vrp)
221 {
222 return STATUS_NO_MEMORY;
223 }
224
225 vrp->StatusBlock = (PSTATUS_BLOCK)&(Irp->IoStatus);
226 vrp->IoControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;
227
228 DPRINT("- IoControlCode: %x\n", vrp->IoControlCode);
229
230 /* We're assuming METHOD_BUFFERED */
231 vrp->InputBuffer = Irp->AssociatedIrp.SystemBuffer;
232 vrp->InputBufferLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;
233 vrp->OutputBuffer = Irp->AssociatedIrp.SystemBuffer;
234 vrp->OutputBufferLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;
235
236 /* Call the Miniport Driver with the VRP */
237 DriverExtension->InitializationData.HwStartIO(
238 &DeviceExtension->MiniPortDeviceExtension,
239 vrp);
240
241 /* Free the VRP */
242 ExFreePool(vrp);
243
244 DPRINT("- Returned status: %x\n", Irp->IoStatus.Status);
245
246 if (Irp->IoStatus.Status != STATUS_SUCCESS)
247 {
248 /* Map from win32 error codes to NT status values. */
249 switch (Irp->IoStatus.Status)
250 {
251 case ERROR_NOT_ENOUGH_MEMORY: Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; break;
252 case ERROR_MORE_DATA: Irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW; break;
253 case ERROR_INVALID_FUNCTION: Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED; break;
254 case ERROR_INVALID_PARAMETER: Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; break;
255 case ERROR_INSUFFICIENT_BUFFER: Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL; break;
256 case ERROR_DEV_NOT_EXIST: Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST; break;
257 case ERROR_IO_PENDING: Irp->IoStatus.Status = STATUS_PENDING; break;
258 }
259 }
260
261 Status = Irp->IoStatus.Status;
262 IoCompleteRequest(Irp, IO_NO_INCREMENT);
263
264 return Status;
265 }
266
267 NTSTATUS NTAPI
268 IntVideoPortPnPStartDevice(
269 IN PDEVICE_OBJECT DeviceObject,
270 IN PIRP Irp)
271 {
272 PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
273 PDRIVER_OBJECT DriverObject;
274 PVIDEO_PORT_DRIVER_EXTENSION DriverExtension;
275 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
276 PCM_RESOURCE_LIST AllocatedResources;
277
278 /*
279 * Get the initialization data we saved in VideoPortInitialize.
280 */
281
282 DriverObject = DeviceObject->DriverObject;
283 DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
284 DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
285
286 /*
287 * Store some resources in the DeviceExtension.
288 */
289
290 AllocatedResources = Stack->Parameters.StartDevice.AllocatedResources;
291 if (AllocatedResources != NULL)
292 {
293 CM_FULL_RESOURCE_DESCRIPTOR *FullList;
294 CM_PARTIAL_RESOURCE_DESCRIPTOR *Descriptor;
295 ULONG ResourceCount;
296 ULONG ResourceListSize;
297
298 /* Save the resource list */
299 ResourceCount = AllocatedResources->List[0].PartialResourceList.Count;
300 ResourceListSize =
301 FIELD_OFFSET(CM_RESOURCE_LIST, List[0].PartialResourceList.
302 PartialDescriptors[ResourceCount]);
303 DeviceExtension->AllocatedResources = ExAllocatePool(PagedPool, ResourceListSize);
304 if (DeviceExtension->AllocatedResources == NULL)
305 {
306 return STATUS_INSUFFICIENT_RESOURCES;
307 }
308
309 RtlCopyMemory(DeviceExtension->AllocatedResources,
310 AllocatedResources,
311 ResourceListSize);
312
313 /* Get the interrupt level/vector - needed by HwFindAdapter sometimes */
314 for (FullList = AllocatedResources->List;
315 FullList < AllocatedResources->List + AllocatedResources->Count;
316 FullList++)
317 {
318 /* FIXME: Is this ASSERT ok for resources from the PNP manager? */
319 ASSERT(FullList->InterfaceType == PCIBus &&
320 FullList->BusNumber == DeviceExtension->SystemIoBusNumber &&
321 1 == FullList->PartialResourceList.Version &&
322 1 == FullList->PartialResourceList.Revision);
323 for (Descriptor = FullList->PartialResourceList.PartialDescriptors;
324 Descriptor < FullList->PartialResourceList.PartialDescriptors + FullList->PartialResourceList.Count;
325 Descriptor++)
326 {
327 if (Descriptor->Type == CmResourceTypeInterrupt)
328 {
329 DeviceExtension->InterruptLevel = Descriptor->u.Interrupt.Level;
330 DeviceExtension->InterruptVector = Descriptor->u.Interrupt.Vector;
331 if (Descriptor->ShareDisposition == CmResourceShareShared)
332 DeviceExtension->InterruptShared = TRUE;
333 else
334 DeviceExtension->InterruptShared = FALSE;
335 }
336 }
337 }
338 }
339 DPRINT("Interrupt level: 0x%x Interrupt Vector: 0x%x\n",
340 DeviceExtension->InterruptLevel,
341 DeviceExtension->InterruptVector);
342
343 /*
344 * Create adapter device object.
345 */
346
347 return IntVideoPortFindAdapter(
348 DriverObject,
349 DriverExtension,
350 DeviceObject);
351 }
352
353
354 NTSTATUS
355 NTAPI
356 IntVideoPortForwardIrpAndWaitCompletionRoutine(
357 PDEVICE_OBJECT Fdo,
358 PIRP Irp,
359 PVOID Context)
360 {
361 PKEVENT Event = Context;
362
363 if (Irp->PendingReturned)
364 KeSetEvent(Event, IO_NO_INCREMENT, FALSE);
365
366 return STATUS_MORE_PROCESSING_REQUIRED;
367 }
368
369
370 NTSTATUS
371 NTAPI
372 IntVideoPortForwardIrpAndWait(PDEVICE_OBJECT DeviceObject, PIRP Irp)
373 {
374 KEVENT Event;
375 NTSTATUS Status;
376 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension =
377 (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
378
379 KeInitializeEvent(&Event, NotificationEvent, FALSE);
380 IoCopyCurrentIrpStackLocationToNext(Irp);
381 IoSetCompletionRoutine(Irp, IntVideoPortForwardIrpAndWaitCompletionRoutine,
382 &Event, TRUE, TRUE, TRUE);
383 Status = IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
384 if (Status == STATUS_PENDING)
385 {
386 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
387 Status = Irp->IoStatus.Status;
388 }
389 return Status;
390 }
391
392
393 NTSTATUS NTAPI
394 IntVideoPortDispatchPnp(
395 IN PDEVICE_OBJECT DeviceObject,
396 IN PIRP Irp)
397 {
398 PIO_STACK_LOCATION IrpSp;
399 NTSTATUS Status;
400
401 IrpSp = IoGetCurrentIrpStackLocation(Irp);
402
403 switch (IrpSp->MinorFunction)
404 {
405 case IRP_MN_START_DEVICE:
406 Status = IntVideoPortForwardIrpAndWait(DeviceObject, Irp);
407 if (NT_SUCCESS(Status) && NT_SUCCESS(Irp->IoStatus.Status))
408 Status = IntVideoPortPnPStartDevice(DeviceObject, Irp);
409 Irp->IoStatus.Status = Status;
410 Irp->IoStatus.Information = 0;
411 IoCompleteRequest(Irp, IO_NO_INCREMENT);
412 break;
413
414
415 case IRP_MN_REMOVE_DEVICE:
416 case IRP_MN_QUERY_REMOVE_DEVICE:
417 case IRP_MN_CANCEL_REMOVE_DEVICE:
418 case IRP_MN_SURPRISE_REMOVAL:
419
420 case IRP_MN_STOP_DEVICE:
421 Status = IntVideoPortForwardIrpAndWait(DeviceObject, Irp);
422 if (NT_SUCCESS(Status) && NT_SUCCESS(Irp->IoStatus.Status))
423 Status = STATUS_SUCCESS;
424 Irp->IoStatus.Status = Status;
425 Irp->IoStatus.Information = 0;
426 IoCompleteRequest(Irp, IO_NO_INCREMENT);
427 break;
428
429 case IRP_MN_QUERY_STOP_DEVICE:
430 case IRP_MN_CANCEL_STOP_DEVICE:
431 Status = STATUS_SUCCESS;
432 Irp->IoStatus.Status = STATUS_SUCCESS;
433 Irp->IoStatus.Information = 0;
434 IoCompleteRequest(Irp, IO_NO_INCREMENT);
435 break;
436
437 default:
438 return STATUS_NOT_IMPLEMENTED;
439 break;
440 }
441
442 return Status;
443 }
444
445 NTSTATUS NTAPI
446 IntVideoPortDispatchCleanup(
447 IN PDEVICE_OBJECT DeviceObject,
448 IN PIRP Irp)
449 {
450 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
451
452 DeviceExtension = DeviceObject->DeviceExtension;
453 RtlFreeUnicodeString(&DeviceExtension->RegistryPath);
454
455 Irp->IoStatus.Status = STATUS_SUCCESS;
456 Irp->IoStatus.Information = 0;
457 IoCompleteRequest(Irp, IO_NO_INCREMENT);
458
459 return STATUS_SUCCESS;
460 }
461
462 NTSTATUS NTAPI
463 IntVideoPortDispatchPower(
464 IN PDEVICE_OBJECT DeviceObject,
465 IN PIRP Irp)
466 {
467 return STATUS_NOT_IMPLEMENTED;
468 }
469
470 VOID NTAPI
471 IntVideoPortUnload(PDRIVER_OBJECT DriverObject)
472 {
473 }