- Synchronize up to trunk's revision r57864.
[reactos.git] / win32ss / drivers / videoprt / resource.c
1 /*
2 * VideoPort driver
3 *
4 * Copyright (C) 2002 - 2005 ReactOS Team
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 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 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 */
21
22 #include "videoprt.h"
23
24 /* PRIVATE FUNCTIONS **********************************************************/
25
26 NTSTATUS NTAPI
27 IntVideoPortGetLegacyResources(
28 IN PVIDEO_PORT_DRIVER_EXTENSION DriverExtension,
29 IN PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension,
30 OUT PVIDEO_ACCESS_RANGE *AccessRanges,
31 OUT PULONG AccessRangeCount)
32 {
33 PCI_COMMON_CONFIG PciConfig;
34 ULONG ReadLength;
35
36 if (!DriverExtension->InitializationData.HwGetLegacyResources &&
37 !DriverExtension->InitializationData.HwLegacyResourceCount)
38 {
39 /* No legacy resources to report */
40 *AccessRangeCount = 0;
41 return STATUS_SUCCESS;
42 }
43
44 if (DriverExtension->InitializationData.HwGetLegacyResources)
45 {
46 ReadLength = HalGetBusData(PCIConfiguration,
47 DeviceExtension->SystemIoBusNumber,
48 DeviceExtension->SystemIoSlotNumber,
49 &PciConfig,
50 sizeof(PciConfig));
51 if (ReadLength != sizeof(PciConfig))
52 {
53 /* This device doesn't exist */
54 return STATUS_NO_SUCH_DEVICE;
55 }
56
57 DriverExtension->InitializationData.HwGetLegacyResources(PciConfig.VendorID,
58 PciConfig.DeviceID,
59 AccessRanges,
60 AccessRangeCount);
61 }
62 else
63 {
64 *AccessRanges = DriverExtension->InitializationData.HwLegacyResourceList;
65 *AccessRangeCount = DriverExtension->InitializationData.HwLegacyResourceCount;
66 }
67
68 INFO_(VIDEOPRT, "Got %d legacy access ranges\n", *AccessRangeCount);
69
70 return STATUS_SUCCESS;
71 }
72
73 NTSTATUS NTAPI
74 IntVideoPortFilterResourceRequirements(
75 IN PDEVICE_OBJECT DeviceObject,
76 IN PIRP Irp)
77 {
78 PDRIVER_OBJECT DriverObject;
79 PVIDEO_PORT_DRIVER_EXTENSION DriverExtension;
80 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
81 PVIDEO_ACCESS_RANGE AccessRanges;
82 ULONG AccessRangeCount, ListSize, i;
83 PIO_RESOURCE_REQUIREMENTS_LIST ResList, OldResList = (PVOID)Irp->IoStatus.Information;
84 PIO_RESOURCE_DESCRIPTOR CurrentDescriptor;
85 NTSTATUS Status;
86
87 DriverObject = DeviceObject->DriverObject;
88 DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
89 DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
90
91 Status = IntVideoPortGetLegacyResources(DriverExtension, DeviceExtension, &AccessRanges, &AccessRangeCount);
92 if (!NT_SUCCESS(Status))
93 return Status;
94 if (!AccessRangeCount)
95 {
96 /* No legacy resources to report */
97 return Irp->IoStatus.Information;
98 }
99
100 /* OK, we've got the access ranges now. Let's set up the resource requirements list */
101
102 if (OldResList)
103 {
104 /* Already one there so let's add to it */
105 ListSize = OldResList->ListSize + sizeof(IO_RESOURCE_DESCRIPTOR) * AccessRangeCount;
106 ResList = ExAllocatePool(NonPagedPool,
107 ListSize);
108 if (!ResList) return STATUS_NO_MEMORY;
109
110 RtlCopyMemory(ResList, OldResList, OldResList->ListSize);
111
112 ASSERT(ResList->AlternativeLists == 1);
113
114 ResList->ListSize = ListSize;
115 ResList->List[0].Count += AccessRangeCount;
116
117 CurrentDescriptor = (PIO_RESOURCE_DESCRIPTOR)((PUCHAR)ResList + OldResList->ListSize);
118
119 ExFreePool(OldResList);
120 Irp->IoStatus.Information = 0;
121 }
122 else
123 {
124 /* We need to make a new one */
125 ListSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST) + sizeof(IO_RESOURCE_DESCRIPTOR) * (AccessRangeCount - 1);
126 ResList = ExAllocatePool(NonPagedPool,
127 ListSize);
128 if (!ResList) return STATUS_NO_MEMORY;
129
130 RtlZeroMemory(ResList, ListSize);
131
132 /* We need to initialize some fields */
133 ResList->ListSize = ListSize;
134 ResList->InterfaceType = DeviceExtension->AdapterInterfaceType;
135 ResList->BusNumber = DeviceExtension->SystemIoBusNumber;
136 ResList->SlotNumber = DeviceExtension->SystemIoSlotNumber;
137 ResList->AlternativeLists = 1;
138 ResList->List[0].Version = 1;
139 ResList->List[0].Revision = 1;
140 ResList->List[0].Count = AccessRangeCount;
141
142 CurrentDescriptor = ResList->List[0].Descriptors;
143 }
144
145 for (i = 0; i < AccessRangeCount; i++)
146 {
147 /* This is a required resource */
148 CurrentDescriptor->Option = 0;
149
150 if (AccessRanges[i].RangeInIoSpace)
151 CurrentDescriptor->Type = CmResourceTypePort;
152 else
153 CurrentDescriptor->Type = CmResourceTypeMemory;
154
155 CurrentDescriptor->ShareDisposition =
156 (AccessRanges[i].RangeShareable ? CmResourceShareShared : CmResourceShareDeviceExclusive);
157
158 CurrentDescriptor->Flags = 0;
159
160 if (CurrentDescriptor->Type == CmResourceTypePort)
161 {
162 CurrentDescriptor->u.Port.Length = AccessRanges[i].RangeLength;
163 CurrentDescriptor->u.Port.MinimumAddress =
164 CurrentDescriptor->u.Port.MaximumAddress = AccessRanges[i].RangeStart;
165 CurrentDescriptor->u.Port.Alignment = 1;
166 if (AccessRanges[i].RangePassive & VIDEO_RANGE_PASSIVE_DECODE)
167 CurrentDescriptor->Flags |= CM_RESOURCE_PORT_PASSIVE_DECODE;
168 if (AccessRanges[i].RangePassive & VIDEO_RANGE_10_BIT_DECODE)
169 CurrentDescriptor->Flags |= CM_RESOURCE_PORT_10_BIT_DECODE;
170 }
171 else
172 {
173 CurrentDescriptor->u.Memory.Length = AccessRanges[i].RangeLength;
174 CurrentDescriptor->u.Memory.MinimumAddress =
175 CurrentDescriptor->u.Memory.MaximumAddress = AccessRanges[i].RangeStart;
176 CurrentDescriptor->u.Memory.Alignment = 1;
177 CurrentDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
178 }
179
180 CurrentDescriptor++;
181 }
182
183 Irp->IoStatus.Information = (ULONG_PTR)ResList;
184
185 return STATUS_SUCCESS;
186 }
187
188 NTSTATUS NTAPI
189 IntVideoPortMapPhysicalMemory(
190 IN HANDLE Process,
191 IN PHYSICAL_ADDRESS PhysicalAddress,
192 IN ULONG SizeInBytes,
193 IN ULONG Protect,
194 IN OUT PVOID *VirtualAddress OPTIONAL)
195 {
196 OBJECT_ATTRIBUTES ObjAttribs;
197 UNICODE_STRING UnicodeString;
198 HANDLE hMemObj;
199 NTSTATUS Status;
200 SIZE_T Size;
201
202 /* Initialize object attribs */
203 RtlInitUnicodeString(&UnicodeString, L"\\Device\\PhysicalMemory");
204 InitializeObjectAttributes(&ObjAttribs,
205 &UnicodeString,
206 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
207 NULL, NULL);
208
209 /* Open physical memory section */
210 Status = ZwOpenSection(&hMemObj, SECTION_ALL_ACCESS, &ObjAttribs);
211 if (!NT_SUCCESS(Status))
212 {
213 WARN_(VIDEOPRT, "ZwOpenSection() failed! (0x%x)\n", Status);
214 return Status;
215 }
216
217 /* Map view of section */
218 Size = SizeInBytes;
219 Status = ZwMapViewOfSection(hMemObj,
220 Process,
221 VirtualAddress,
222 0,
223 Size,
224 (PLARGE_INTEGER)(&PhysicalAddress),
225 &Size,
226 ViewUnmap,
227 0,
228 Protect);
229 ZwClose(hMemObj);
230 if (!NT_SUCCESS(Status))
231 {
232 WARN_(VIDEOPRT, "ZwMapViewOfSection() failed! (0x%x)\n", Status);
233 }
234
235 return Status;
236 }
237
238
239 PVOID NTAPI
240 IntVideoPortMapMemory(
241 IN PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension,
242 IN PHYSICAL_ADDRESS IoAddress,
243 IN ULONG NumberOfUchars,
244 IN ULONG InIoSpace,
245 IN HANDLE ProcessHandle,
246 OUT VP_STATUS *Status)
247 {
248 PHYSICAL_ADDRESS TranslatedAddress;
249 PVIDEO_PORT_ADDRESS_MAPPING AddressMapping;
250 ULONG AddressSpace;
251 PVOID MappedAddress;
252 PLIST_ENTRY Entry;
253
254 INFO_(VIDEOPRT, "- IoAddress: %lx\n", IoAddress.u.LowPart);
255 INFO_(VIDEOPRT, "- NumberOfUchars: %lx\n", NumberOfUchars);
256 INFO_(VIDEOPRT, "- InIoSpace: %x\n", InIoSpace);
257
258 InIoSpace &= ~VIDEO_MEMORY_SPACE_DENSE;
259 if ((InIoSpace & VIDEO_MEMORY_SPACE_P6CACHE) != 0)
260 {
261 INFO_(VIDEOPRT, "VIDEO_MEMORY_SPACE_P6CACHE not supported, turning off\n");
262 InIoSpace &= ~VIDEO_MEMORY_SPACE_P6CACHE;
263 }
264
265 if (ProcessHandle != NULL && (InIoSpace & VIDEO_MEMORY_SPACE_USER_MODE) == 0)
266 {
267 INFO_(VIDEOPRT, "ProcessHandle is not NULL (0x%x) but InIoSpace does not have "
268 "VIDEO_MEMORY_SPACE_USER_MODE set! Setting "
269 "VIDEO_MEMORY_SPACE_USER_MODE.\n",
270 ProcessHandle);
271 InIoSpace |= VIDEO_MEMORY_SPACE_USER_MODE;
272 }
273 else if (ProcessHandle == NULL && (InIoSpace & VIDEO_MEMORY_SPACE_USER_MODE) != 0)
274 {
275 INFO_(VIDEOPRT, "ProcessHandle is NULL (0x%x) but InIoSpace does have "
276 "VIDEO_MEMORY_SPACE_USER_MODE set! Setting ProcessHandle "
277 "to NtCurrentProcess()\n",
278 ProcessHandle);
279 ProcessHandle = NtCurrentProcess();
280 }
281
282 if ((InIoSpace & VIDEO_MEMORY_SPACE_USER_MODE) == 0 &&
283 !IsListEmpty(&DeviceExtension->AddressMappingListHead))
284 {
285 Entry = DeviceExtension->AddressMappingListHead.Flink;
286 while (Entry != &DeviceExtension->AddressMappingListHead)
287 {
288 AddressMapping = CONTAINING_RECORD(
289 Entry,
290 VIDEO_PORT_ADDRESS_MAPPING,
291 List);
292 if (IoAddress.QuadPart == AddressMapping->IoAddress.QuadPart &&
293 NumberOfUchars <= AddressMapping->NumberOfUchars)
294 {
295 {
296 AddressMapping->MappingCount++;
297 if (Status)
298 *Status = NO_ERROR;
299 return AddressMapping->MappedAddress;
300 }
301 }
302 Entry = Entry->Flink;
303 }
304 }
305
306 AddressSpace = (ULONG)InIoSpace;
307 AddressSpace &= ~VIDEO_MEMORY_SPACE_USER_MODE;
308 if (HalTranslateBusAddress(
309 DeviceExtension->AdapterInterfaceType,
310 DeviceExtension->SystemIoBusNumber,
311 IoAddress,
312 &AddressSpace,
313 &TranslatedAddress) == FALSE)
314 {
315 if (Status)
316 *Status = ERROR_NOT_ENOUGH_MEMORY;
317
318 return NULL;
319 }
320
321 /* I/O space */
322 if (AddressSpace != 0)
323 {
324 ASSERT(0 == TranslatedAddress.u.HighPart);
325 if (Status)
326 *Status = NO_ERROR;
327
328 return (PVOID)(ULONG_PTR)TranslatedAddress.u.LowPart;
329 }
330
331 /* user space */
332 if ((InIoSpace & VIDEO_MEMORY_SPACE_USER_MODE) != 0)
333 {
334 NTSTATUS NtStatus;
335 MappedAddress = NULL;
336 NtStatus = IntVideoPortMapPhysicalMemory(ProcessHandle,
337 TranslatedAddress,
338 NumberOfUchars,
339 PAGE_READWRITE/* | PAGE_WRITECOMBINE*/,
340 &MappedAddress);
341 if (!NT_SUCCESS(NtStatus))
342 {
343 WARN_(VIDEOPRT, "IntVideoPortMapPhysicalMemory() failed! (0x%x)\n", NtStatus);
344 if (Status)
345 *Status = NO_ERROR;
346 return NULL;
347 }
348 INFO_(VIDEOPRT, "Mapped user address = 0x%08x\n", MappedAddress);
349 }
350 else /* kernel space */
351 {
352 MappedAddress = MmMapIoSpace(
353 TranslatedAddress,
354 NumberOfUchars,
355 MmNonCached);
356 }
357
358 if (MappedAddress != NULL)
359 {
360 if (Status)
361 {
362 *Status = NO_ERROR;
363 }
364 if ((InIoSpace & VIDEO_MEMORY_SPACE_USER_MODE) == 0)
365 {
366 AddressMapping = ExAllocatePoolWithTag(
367 PagedPool,
368 sizeof(VIDEO_PORT_ADDRESS_MAPPING),
369 TAG_VIDEO_PORT);
370
371 if (AddressMapping == NULL)
372 return MappedAddress;
373
374 RtlZeroMemory(AddressMapping, sizeof(VIDEO_PORT_ADDRESS_MAPPING));
375 AddressMapping->NumberOfUchars = NumberOfUchars;
376 AddressMapping->IoAddress = IoAddress;
377 AddressMapping->SystemIoBusNumber = DeviceExtension->SystemIoBusNumber;
378 AddressMapping->MappedAddress = MappedAddress;
379 AddressMapping->MappingCount = 1;
380 InsertHeadList(
381 &DeviceExtension->AddressMappingListHead,
382 &AddressMapping->List);
383 }
384
385 return MappedAddress;
386 }
387
388 if (Status)
389 *Status = NO_ERROR;
390
391 return NULL;
392 }
393
394 VOID NTAPI
395 IntVideoPortUnmapMemory(
396 IN PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension,
397 IN PVOID MappedAddress)
398 {
399 PVIDEO_PORT_ADDRESS_MAPPING AddressMapping;
400 PLIST_ENTRY Entry;
401 NTSTATUS Status;
402
403 Entry = DeviceExtension->AddressMappingListHead.Flink;
404 while (Entry != &DeviceExtension->AddressMappingListHead)
405 {
406 AddressMapping = CONTAINING_RECORD(
407 Entry,
408 VIDEO_PORT_ADDRESS_MAPPING,
409 List);
410 if (AddressMapping->MappedAddress == MappedAddress)
411 {
412 ASSERT(AddressMapping->MappingCount > 0);
413 AddressMapping->MappingCount--;
414 if (AddressMapping->MappingCount == 0)
415 {
416 MmUnmapIoSpace(
417 AddressMapping->MappedAddress,
418 AddressMapping->NumberOfUchars);
419 RemoveEntryList(Entry);
420 ExFreePool(AddressMapping);
421 }
422 return;
423 }
424
425 Entry = Entry->Flink;
426 }
427
428 /* If there was no kernelmode mapping for the given address found we assume
429 * that the given address is a usermode mapping and try to unmap it.
430 *
431 * FIXME: Is it ok to use NtCurrentProcess?
432 */
433 Status = ZwUnmapViewOfSection(NtCurrentProcess(), MappedAddress);
434 if (!NT_SUCCESS(Status))
435 {
436 WARN_(VIDEOPRT, "Warning: Mapping for address 0x%p not found!\n", MappedAddress);
437 }
438 }
439
440 /* PUBLIC FUNCTIONS ***********************************************************/
441
442 /*
443 * @implemented
444 */
445
446 PVOID NTAPI
447 VideoPortGetDeviceBase(
448 IN PVOID HwDeviceExtension,
449 IN PHYSICAL_ADDRESS IoAddress,
450 IN ULONG NumberOfUchars,
451 IN UCHAR InIoSpace)
452 {
453 TRACE_(VIDEOPRT, "VideoPortGetDeviceBase\n");
454 return IntVideoPortMapMemory(
455 VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension),
456 IoAddress,
457 NumberOfUchars,
458 InIoSpace,
459 NULL,
460 NULL);
461 }
462
463 /*
464 * @implemented
465 */
466
467 VOID NTAPI
468 VideoPortFreeDeviceBase(
469 IN PVOID HwDeviceExtension,
470 IN PVOID MappedAddress)
471 {
472 TRACE_(VIDEOPRT, "VideoPortFreeDeviceBase\n");
473 IntVideoPortUnmapMemory(
474 VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension),
475 MappedAddress);
476 }
477
478 /*
479 * @unimplemented
480 */
481
482 VP_STATUS NTAPI
483 VideoPortMapBankedMemory(
484 IN PVOID HwDeviceExtension,
485 IN PHYSICAL_ADDRESS PhysicalAddress,
486 IN PULONG Length,
487 IN PULONG InIoSpace,
488 OUT PVOID *VirtualAddress,
489 IN ULONG BankLength,
490 IN UCHAR ReadWriteBank,
491 IN PBANKED_SECTION_ROUTINE BankRoutine,
492 IN PVOID Context)
493 {
494 TRACE_(VIDEOPRT, "VideoPortMapBankedMemory\n");
495 UNIMPLEMENTED;
496 return ERROR_INVALID_FUNCTION;
497 }
498
499
500 /*
501 * @implemented
502 */
503
504 VP_STATUS NTAPI
505 VideoPortMapMemory(
506 IN PVOID HwDeviceExtension,
507 IN PHYSICAL_ADDRESS PhysicalAddress,
508 IN PULONG Length,
509 IN PULONG InIoSpace,
510 OUT PVOID *VirtualAddress)
511 {
512 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
513 NTSTATUS Status;
514
515 TRACE_(VIDEOPRT, "VideoPortMapMemory\n");
516 INFO_(VIDEOPRT, "- *VirtualAddress: 0x%x\n", *VirtualAddress);
517
518 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
519 *VirtualAddress = IntVideoPortMapMemory(
520 DeviceExtension,
521 PhysicalAddress,
522 *Length,
523 *InIoSpace,
524 (HANDLE)*VirtualAddress,
525 &Status);
526
527 return Status;
528 }
529
530 /*
531 * @implemented
532 */
533
534 VP_STATUS NTAPI
535 VideoPortUnmapMemory(
536 IN PVOID HwDeviceExtension,
537 IN PVOID VirtualAddress,
538 IN HANDLE ProcessHandle)
539 {
540 TRACE_(VIDEOPRT, "VideoPortFreeDeviceBase\n");
541
542 IntVideoPortUnmapMemory(
543 VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension),
544 VirtualAddress);
545
546 return NO_ERROR;
547 }
548
549 /*
550 * @implemented
551 */
552
553 VP_STATUS NTAPI
554 VideoPortGetAccessRanges(
555 IN PVOID HwDeviceExtension,
556 IN ULONG NumRequestedResources,
557 IN PIO_RESOURCE_DESCRIPTOR RequestedResources OPTIONAL,
558 IN ULONG NumAccessRanges,
559 IN PVIDEO_ACCESS_RANGE AccessRanges,
560 IN PVOID VendorId,
561 IN PVOID DeviceId,
562 OUT PULONG Slot)
563 {
564 PCI_SLOT_NUMBER PciSlotNumber;
565 ULONG DeviceNumber;
566 ULONG FunctionNumber;
567 PCI_COMMON_CONFIG Config;
568 PCM_RESOURCE_LIST AllocatedResources;
569 NTSTATUS Status;
570 UINT AssignedCount = 0;
571 CM_FULL_RESOURCE_DESCRIPTOR *FullList;
572 CM_PARTIAL_RESOURCE_DESCRIPTOR *Descriptor;
573 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
574 PVIDEO_PORT_DRIVER_EXTENSION DriverExtension;
575 USHORT VendorIdToFind;
576 USHORT DeviceIdToFind;
577 ULONG ReturnedLength;
578 PVIDEO_ACCESS_RANGE LegacyAccessRanges;
579 ULONG LegacyAccessRangeCount;
580 PDRIVER_OBJECT DriverObject;
581 ULONG ListSize;
582 PIO_RESOURCE_REQUIREMENTS_LIST ResReqList;
583 BOOLEAN DeviceAndVendorFound = FALSE;
584
585 TRACE_(VIDEOPRT, "VideoPortGetAccessRanges(%d, %p, %d, %p)\n", NumRequestedResources, RequestedResources, NumAccessRanges, AccessRanges);
586
587 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
588 DriverObject = DeviceExtension->DriverObject;
589 DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
590
591 if (NumRequestedResources == 0)
592 {
593 AllocatedResources = DeviceExtension->AllocatedResources;
594 if (AllocatedResources == NULL &&
595 DeviceExtension->AdapterInterfaceType == PCIBus)
596 {
597 if (DeviceExtension->PhysicalDeviceObject != NULL)
598 {
599 PciSlotNumber.u.AsULONG = DeviceExtension->SystemIoSlotNumber;
600
601 ReturnedLength = HalGetBusData(PCIConfiguration,
602 DeviceExtension->SystemIoBusNumber,
603 PciSlotNumber.u.AsULONG,
604 &Config,
605 sizeof(PCI_COMMON_CONFIG));
606
607 if (ReturnedLength != sizeof(PCI_COMMON_CONFIG))
608 {
609 return ERROR_NOT_ENOUGH_MEMORY;
610 }
611 }
612 else
613 {
614 VendorIdToFind = VendorId != NULL ? *(PUSHORT)VendorId : 0;
615 DeviceIdToFind = DeviceId != NULL ? *(PUSHORT)DeviceId : 0;
616
617 if (VendorIdToFind == 0 && DeviceIdToFind == 0)
618 {
619 /* We're screwed */
620 return ERROR_DEV_NOT_EXIST;
621 }
622
623 INFO_(VIDEOPRT, "Looking for VendorId 0x%04x DeviceId 0x%04x\n",
624 VendorIdToFind, DeviceIdToFind);
625
626 /*
627 * Search for the device id and vendor id on this bus.
628 */
629 for (DeviceNumber = 0; DeviceNumber < PCI_MAX_DEVICES; DeviceNumber++)
630 {
631 PciSlotNumber.u.bits.DeviceNumber = DeviceNumber;
632 for (FunctionNumber = 0; FunctionNumber < PCI_MAX_FUNCTION; FunctionNumber++)
633 {
634 INFO_(VIDEOPRT, "- Function number: %d\n", FunctionNumber);
635 PciSlotNumber.u.bits.FunctionNumber = FunctionNumber;
636 ReturnedLength = HalGetBusData(PCIConfiguration,
637 DeviceExtension->SystemIoBusNumber,
638 PciSlotNumber.u.AsULONG,
639 &Config,
640 sizeof(PCI_COMMON_CONFIG));
641 INFO_(VIDEOPRT, "- Length of data: %x\n", ReturnedLength);
642 if (ReturnedLength == sizeof(PCI_COMMON_CONFIG))
643 {
644 INFO_(VIDEOPRT, "- Slot 0x%02x (Device %d Function %d) VendorId 0x%04x "
645 "DeviceId 0x%04x\n",
646 PciSlotNumber.u.AsULONG,
647 PciSlotNumber.u.bits.DeviceNumber,
648 PciSlotNumber.u.bits.FunctionNumber,
649 Config.VendorID,
650 Config.DeviceID);
651
652 if ((VendorIdToFind == 0 || Config.VendorID == VendorIdToFind) &&
653 (DeviceIdToFind == 0 || Config.DeviceID == DeviceIdToFind))
654 {
655 DeviceAndVendorFound = TRUE;
656 break;
657 }
658 }
659 }
660 if (DeviceAndVendorFound) break;
661 }
662 if (FunctionNumber == PCI_MAX_FUNCTION)
663 {
664 WARN_(VIDEOPRT, "Didn't find device.\n");
665 return ERROR_DEV_NOT_EXIST;
666 }
667 }
668
669 Status = HalAssignSlotResources(&DeviceExtension->RegistryPath,
670 NULL,
671 DeviceExtension->DriverObject,
672 DeviceExtension->DriverObject->DeviceObject,
673 DeviceExtension->AdapterInterfaceType,
674 DeviceExtension->SystemIoBusNumber,
675 PciSlotNumber.u.AsULONG,
676 &AllocatedResources);
677
678 if (!NT_SUCCESS(Status))
679 {
680 WARN_(VIDEOPRT, "HalAssignSlotResources failed with status %x.\n",Status);
681 return Status;
682 }
683 DeviceExtension->AllocatedResources = AllocatedResources;
684 DeviceExtension->SystemIoSlotNumber = PciSlotNumber.u.AsULONG;
685
686 /* Add legacy resources to the resources from HAL */
687 Status = IntVideoPortGetLegacyResources(DriverExtension, DeviceExtension,
688 &LegacyAccessRanges, &LegacyAccessRangeCount);
689 if (!NT_SUCCESS(Status))
690 return ERROR_DEV_NOT_EXIST;
691
692 if (NumAccessRanges < LegacyAccessRangeCount)
693 {
694 ERR_(VIDEOPRT, "Too many legacy access ranges found\n");
695 return ERROR_NOT_ENOUGH_MEMORY;
696 }
697
698 RtlCopyMemory(AccessRanges, LegacyAccessRanges, LegacyAccessRangeCount * sizeof(VIDEO_ACCESS_RANGE));
699 AssignedCount = LegacyAccessRangeCount;
700 }
701 }
702 else
703 {
704 ListSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST) + (NumRequestedResources - 1) * sizeof(IO_RESOURCE_DESCRIPTOR);
705 ResReqList = ExAllocatePool(NonPagedPool, ListSize);
706 if (!ResReqList) return ERROR_NOT_ENOUGH_MEMORY;
707
708 ResReqList->ListSize = ListSize;
709 ResReqList->InterfaceType = DeviceExtension->AdapterInterfaceType;
710 ResReqList->BusNumber = DeviceExtension->SystemIoBusNumber;
711 ResReqList->SlotNumber = DeviceExtension->SystemIoSlotNumber;
712 ResReqList->AlternativeLists = 1;
713 ResReqList->List[0].Version = 1;
714 ResReqList->List[0].Revision = 1;
715 ResReqList->List[0].Count = NumRequestedResources;
716
717 /* Copy in the caller's resource list */
718 RtlCopyMemory(ResReqList->List[0].Descriptors,
719 RequestedResources,
720 NumRequestedResources * sizeof(IO_RESOURCE_DESCRIPTOR));
721
722 Status = IoAssignResources(&DeviceExtension->RegistryPath,
723 NULL,
724 DeviceExtension->DriverObject,
725 DeviceExtension->PhysicalDeviceObject ?
726 DeviceExtension->PhysicalDeviceObject :
727 DeviceExtension->DriverObject->DeviceObject,
728 ResReqList,
729 &AllocatedResources);
730
731 if (!NT_SUCCESS(Status))
732 return Status;
733
734 if (!DeviceExtension->AllocatedResources)
735 DeviceExtension->AllocatedResources = AllocatedResources;
736 }
737
738 if (AllocatedResources == NULL)
739 return ERROR_NOT_ENOUGH_MEMORY;
740
741 /* Return the slot number if the caller wants it */
742 if (Slot != NULL) *Slot = DeviceExtension->SystemIoBusNumber;
743
744 for (FullList = AllocatedResources->List;
745 FullList < AllocatedResources->List + AllocatedResources->Count;
746 FullList++)
747 {
748 INFO_(VIDEOPRT, "InterfaceType %u BusNumber List %u Device BusNumber %u Version %u Revision %u\n",
749 FullList->InterfaceType, FullList->BusNumber, DeviceExtension->SystemIoBusNumber, FullList->PartialResourceList.Version, FullList->PartialResourceList.Revision);
750
751 ASSERT(FullList->InterfaceType == PCIBus);
752 ASSERT(FullList->BusNumber == DeviceExtension->SystemIoBusNumber);
753 ASSERT(1 == FullList->PartialResourceList.Version);
754 ASSERT(1 == FullList->PartialResourceList.Revision);
755 for (Descriptor = FullList->PartialResourceList.PartialDescriptors;
756 Descriptor < FullList->PartialResourceList.PartialDescriptors + FullList->PartialResourceList.Count;
757 Descriptor++)
758 {
759 if ((Descriptor->Type == CmResourceTypeMemory ||
760 Descriptor->Type == CmResourceTypePort) &&
761 AssignedCount >= NumAccessRanges)
762 {
763 ERR_(VIDEOPRT, "Too many access ranges found\n");
764 return ERROR_NOT_ENOUGH_MEMORY;
765 }
766 if (Descriptor->Type == CmResourceTypeMemory)
767 {
768 INFO_(VIDEOPRT, "Memory range starting at 0x%08x length 0x%08x\n",
769 Descriptor->u.Memory.Start.u.LowPart, Descriptor->u.Memory.Length);
770 AccessRanges[AssignedCount].RangeStart = Descriptor->u.Memory.Start;
771 AccessRanges[AssignedCount].RangeLength = Descriptor->u.Memory.Length;
772 AccessRanges[AssignedCount].RangeInIoSpace = 0;
773 AccessRanges[AssignedCount].RangeVisible = 0; /* FIXME: Just guessing */
774 AccessRanges[AssignedCount].RangeShareable =
775 (Descriptor->ShareDisposition == CmResourceShareShared);
776 AccessRanges[AssignedCount].RangePassive = 0;
777 AssignedCount++;
778 }
779 else if (Descriptor->Type == CmResourceTypePort)
780 {
781 INFO_(VIDEOPRT, "Port range starting at 0x%04x length %d\n",
782 Descriptor->u.Port.Start.u.LowPart, Descriptor->u.Port.Length);
783 AccessRanges[AssignedCount].RangeStart = Descriptor->u.Port.Start;
784 AccessRanges[AssignedCount].RangeLength = Descriptor->u.Port.Length;
785 AccessRanges[AssignedCount].RangeInIoSpace = 1;
786 AccessRanges[AssignedCount].RangeVisible = 0; /* FIXME: Just guessing */
787 AccessRanges[AssignedCount].RangeShareable =
788 (Descriptor->ShareDisposition == CmResourceShareShared);
789 AccessRanges[AssignedCount].RangePassive = 0;
790 if (Descriptor->Flags & CM_RESOURCE_PORT_10_BIT_DECODE)
791 AccessRanges[AssignedCount].RangePassive |= VIDEO_RANGE_10_BIT_DECODE;
792 if (Descriptor->Flags & CM_RESOURCE_PORT_PASSIVE_DECODE)
793 AccessRanges[AssignedCount].RangePassive |= VIDEO_RANGE_PASSIVE_DECODE;
794 AssignedCount++;
795 }
796 else if (Descriptor->Type == CmResourceTypeInterrupt)
797 {
798 DeviceExtension->InterruptLevel = Descriptor->u.Interrupt.Level;
799 DeviceExtension->InterruptVector = Descriptor->u.Interrupt.Vector;
800 if (Descriptor->ShareDisposition == CmResourceShareShared)
801 DeviceExtension->InterruptShared = TRUE;
802 else
803 DeviceExtension->InterruptShared = FALSE;
804 }
805 }
806 }
807
808 return NO_ERROR;
809 }
810
811 /*
812 * @implemented
813 */
814
815 VP_STATUS NTAPI
816 VideoPortVerifyAccessRanges(
817 IN PVOID HwDeviceExtension,
818 IN ULONG NumAccessRanges,
819 IN PVIDEO_ACCESS_RANGE AccessRanges)
820 {
821 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
822 BOOLEAN ConflictDetected;
823 ULONG i;
824 PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
825 PCM_RESOURCE_LIST ResourceList;
826 ULONG ResourceListSize;
827 NTSTATUS Status;
828
829 TRACE_(VIDEOPRT, "VideoPortVerifyAccessRanges\n");
830
831 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
832
833 /* Create the resource list */
834 ResourceListSize = sizeof(CM_RESOURCE_LIST)
835 + (NumAccessRanges - 1) * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
836 ResourceList = ExAllocatePool(PagedPool, ResourceListSize);
837 if (!ResourceList)
838 {
839 WARN_(VIDEOPRT, "ExAllocatePool() failed\n");
840 return ERROR_INVALID_PARAMETER;
841 }
842
843 /* Fill resource list */
844 ResourceList->Count = 1;
845 ResourceList->List[0].InterfaceType = DeviceExtension->AdapterInterfaceType;
846 ResourceList->List[0].BusNumber = DeviceExtension->SystemIoBusNumber;
847 ResourceList->List[0].PartialResourceList.Version = 1;
848 ResourceList->List[0].PartialResourceList.Revision = 1;
849 ResourceList->List[0].PartialResourceList.Count = NumAccessRanges;
850 for (i = 0; i < NumAccessRanges; i++, AccessRanges++)
851 {
852 PartialDescriptor = &ResourceList->List[0].PartialResourceList.PartialDescriptors[i];
853 if (AccessRanges->RangeInIoSpace)
854 {
855 PartialDescriptor->Type = CmResourceTypePort;
856 PartialDescriptor->u.Port.Start = AccessRanges->RangeStart;
857 PartialDescriptor->u.Port.Length = AccessRanges->RangeLength;
858 }
859 else
860 {
861 PartialDescriptor->Type = CmResourceTypeMemory;
862 PartialDescriptor->u.Memory.Start = AccessRanges->RangeStart;
863 PartialDescriptor->u.Memory.Length = AccessRanges->RangeLength;
864 }
865 if (AccessRanges->RangeShareable)
866 PartialDescriptor->ShareDisposition = CmResourceShareShared;
867 else
868 PartialDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
869 PartialDescriptor->Flags = 0;
870 if (AccessRanges->RangePassive & VIDEO_RANGE_PASSIVE_DECODE)
871 PartialDescriptor->Flags |= CM_RESOURCE_PORT_PASSIVE_DECODE;
872 if (AccessRanges->RangePassive & VIDEO_RANGE_10_BIT_DECODE)
873 PartialDescriptor->Flags |= CM_RESOURCE_PORT_10_BIT_DECODE;
874 }
875
876 /* Try to acquire all resource ranges */
877 Status = IoReportResourceForDetection(
878 DeviceExtension->DriverObject,
879 NULL, 0, /* Driver List */
880 DeviceExtension->PhysicalDeviceObject,
881 ResourceList, ResourceListSize,
882 &ConflictDetected);
883 ExFreePool(ResourceList);
884
885 if (!NT_SUCCESS(Status) || ConflictDetected)
886 return ERROR_INVALID_PARAMETER;
887 else
888 return NO_ERROR;
889 }
890
891 /*
892 * @unimplemented
893 */
894
895 VP_STATUS NTAPI
896 VideoPortGetDeviceData(
897 IN PVOID HwDeviceExtension,
898 IN VIDEO_DEVICE_DATA_TYPE DeviceDataType,
899 IN PMINIPORT_QUERY_DEVICE_ROUTINE CallbackRoutine,
900 IN PVOID Context)
901 {
902 TRACE_(VIDEOPRT, "VideoPortGetDeviceData\n");
903 UNIMPLEMENTED;
904 return ERROR_INVALID_FUNCTION;
905 }
906
907 /*
908 * @implemented
909 */
910
911 PVOID NTAPI
912 VideoPortAllocatePool(
913 IN PVOID HwDeviceExtension,
914 IN VP_POOL_TYPE PoolType,
915 IN SIZE_T NumberOfBytes,
916 IN ULONG Tag)
917 {
918 TRACE_(VIDEOPRT, "VideoPortAllocatePool\n");
919 return ExAllocatePoolWithTag(PoolType, NumberOfBytes, Tag);
920 }
921
922 /*
923 * @implemented
924 */
925
926 VOID NTAPI
927 VideoPortFreePool(
928 IN PVOID HwDeviceExtension,
929 IN PVOID Ptr)
930 {
931 ExFreePool(Ptr);
932 }
933
934 /*
935 * @implemented
936 */
937
938 VP_STATUS NTAPI
939 VideoPortAllocateBuffer(
940 IN PVOID HwDeviceExtension,
941 IN ULONG Size,
942 OUT PVOID *Buffer)
943 {
944 TRACE_(VIDEOPRT, "VideoPortAllocateBuffer\n");
945 *Buffer = ExAllocatePoolWithTag ( PagedPool, Size, TAG_VIDEO_PORT_BUFFER ) ;
946 return *Buffer == NULL ? ERROR_NOT_ENOUGH_MEMORY : NO_ERROR;
947 }
948
949 /*
950 * @implemented
951 */
952
953 VOID NTAPI
954 VideoPortReleaseBuffer(
955 IN PVOID HwDeviceExtension,
956 IN PVOID Ptr)
957 {
958 TRACE_(VIDEOPRT, "VideoPortReleaseBuffer\n");
959 ExFreePool(Ptr);
960 }
961
962 /*
963 * @implemented
964 */
965
966 PVOID NTAPI
967 VideoPortLockBuffer(
968 IN PVOID HwDeviceExtension,
969 IN PVOID BaseAddress,
970 IN ULONG Length,
971 IN VP_LOCK_OPERATION Operation)
972 {
973 PMDL Mdl;
974
975 Mdl = IoAllocateMdl(BaseAddress, Length, FALSE, FALSE, NULL);
976 if (!Mdl)
977 {
978 return NULL;
979 }
980 /* FIXME use seh */
981 MmProbeAndLockPages(Mdl, KernelMode,Operation);
982 return Mdl;
983 }
984
985 /*
986 * @implemented
987 */
988
989 BOOLEAN
990 NTAPI
991 VideoPortLockPages(
992 IN PVOID HwDeviceExtension,
993 IN OUT PVIDEO_REQUEST_PACKET pVrp,
994 IN PEVENT pUEvent,
995 IN PEVENT pDisplayEvent,
996 IN DMA_FLAGS DmaFlags)
997 {
998 PVOID Buffer;
999
1000 /* clear output buffer */
1001 pVrp->OutputBuffer = NULL;
1002
1003 if (DmaFlags != VideoPortDmaInitOnly)
1004 {
1005 /* VideoPortKeepPagesLocked / VideoPortUnlockAfterDma is no-op */
1006 return FALSE;
1007 }
1008
1009 /* lock the buffer */
1010 Buffer = VideoPortLockBuffer(HwDeviceExtension, pVrp->InputBuffer, pVrp->InputBufferLength, IoModifyAccess);
1011
1012 if (Buffer)
1013 {
1014 /* store result buffer & length */
1015 pVrp->OutputBuffer = Buffer;
1016 pVrp->OutputBufferLength = pVrp->InputBufferLength;
1017
1018 /* operation succeeded */
1019 return TRUE;
1020 }
1021
1022 /* operation failed */
1023 return FALSE;
1024 }
1025
1026
1027 /*
1028 * @implemented
1029 */
1030
1031 VOID NTAPI
1032 VideoPortUnlockBuffer(
1033 IN PVOID HwDeviceExtension,
1034 IN PVOID Mdl)
1035 {
1036 if (Mdl)
1037 {
1038 MmUnlockPages((PMDL)Mdl);
1039 IoFreeMdl(Mdl);
1040 }
1041 }
1042
1043 /*
1044 * @unimplemented
1045 */
1046
1047 VP_STATUS NTAPI
1048 VideoPortSetTrappedEmulatorPorts(
1049 IN PVOID HwDeviceExtension,
1050 IN ULONG NumAccessRanges,
1051 IN PVIDEO_ACCESS_RANGE AccessRange)
1052 {
1053 UNIMPLEMENTED;
1054 /* Should store the ranges in the device extension for use by ntvdm. */
1055 return NO_ERROR;
1056 }
1057
1058 /*
1059 * @implemented
1060 */
1061
1062 ULONG NTAPI
1063 VideoPortGetBusData(
1064 IN PVOID HwDeviceExtension,
1065 IN BUS_DATA_TYPE BusDataType,
1066 IN ULONG SlotNumber,
1067 OUT PVOID Buffer,
1068 IN ULONG Offset,
1069 IN ULONG Length)
1070 {
1071 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1072
1073 TRACE_(VIDEOPRT, "VideoPortGetBusData\n");
1074
1075 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
1076
1077 if (BusDataType != Cmos)
1078 {
1079 /* Legacy vs. PnP behaviour */
1080 if (DeviceExtension->PhysicalDeviceObject != NULL)
1081 SlotNumber = DeviceExtension->SystemIoSlotNumber;
1082 }
1083
1084 return HalGetBusDataByOffset(
1085 BusDataType,
1086 DeviceExtension->SystemIoBusNumber,
1087 SlotNumber,
1088 Buffer,
1089 Offset,
1090 Length);
1091 }
1092
1093 /*
1094 * @implemented
1095 */
1096
1097 ULONG NTAPI
1098 VideoPortSetBusData(
1099 IN PVOID HwDeviceExtension,
1100 IN BUS_DATA_TYPE BusDataType,
1101 IN ULONG SlotNumber,
1102 IN PVOID Buffer,
1103 IN ULONG Offset,
1104 IN ULONG Length)
1105 {
1106 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1107
1108 TRACE_(VIDEOPRT, "VideoPortSetBusData\n");
1109
1110 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
1111
1112 if (BusDataType != Cmos)
1113 {
1114 /* Legacy vs. PnP behaviour */
1115 if (DeviceExtension->PhysicalDeviceObject != NULL)
1116 SlotNumber = DeviceExtension->SystemIoSlotNumber;
1117 }
1118
1119 return HalSetBusDataByOffset(
1120 BusDataType,
1121 DeviceExtension->SystemIoBusNumber,
1122 SlotNumber,
1123 Buffer,
1124 Offset,
1125 Length);
1126 }