xref: /reactos/win32ss/drivers/videoprt/int10.c (revision e419195d) 
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 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 #include <ndk/kefuncs.h>
25 #include <ndk/halfuncs.h>
26 
27 #define NDEBUG
28 #include <debug.h>
29 
30 /* PRIVATE FUNCTIONS **********************************************************/
31 
32 #if defined(_M_IX86) || defined(_M_AMD64)
33 NTSTATUS
34 NTAPI
35 IntInitializeVideoAddressSpace(VOID)
36 {
37     OBJECT_ATTRIBUTES ObjectAttributes;
38     UNICODE_STRING PhysMemName = RTL_CONSTANT_STRING(L"\\Device\\PhysicalMemory");
39     NTSTATUS Status;
40     HANDLE PhysMemHandle;
41     PVOID BaseAddress;
42     LARGE_INTEGER Offset;
43     SIZE_T ViewSize;
44 #ifdef _M_IX86
45     CHAR IVTAndBda[1024 + 256];
46 #endif // _M_IX86
47 
48     /* Free the 1MB pre-reserved region. In reality, ReactOS should simply support us mapping the view into the reserved area, but it doesn't. */
49     BaseAddress = 0;
50     ViewSize = 1024 * 1024;
51     Status = ZwFreeVirtualMemory(NtCurrentProcess(),
52                                  &BaseAddress,
53                                  &ViewSize,
54                                  MEM_RELEASE);
55     if (!NT_SUCCESS(Status))
56     {
57         DPRINT1("Couldn't unmap reserved memory (%x)\n", Status);
58         return 0;
59     }
60 
61     /* Open the physical memory section */
62     InitializeObjectAttributes(&ObjectAttributes,
63                                &PhysMemName,
64                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
65                                NULL,
66                                NULL);
67     Status = ZwOpenSection(&PhysMemHandle,
68                            SECTION_ALL_ACCESS,
69                            &ObjectAttributes);
70     if (!NT_SUCCESS(Status))
71     {
72         DPRINT1("Couldn't open \\Device\\PhysicalMemory\n");
73         return Status;
74     }
75 
76     /* Map the BIOS and device registers into the address space */
77     Offset.QuadPart = 0xa0000;
78     ViewSize = 0x100000 - 0xa0000;
79     BaseAddress = (PVOID)0xa0000;
80     Status = ZwMapViewOfSection(PhysMemHandle,
81                                 NtCurrentProcess(),
82                                 &BaseAddress,
83                                 0,
84                                 ViewSize,
85                                 &Offset,
86                                 &ViewSize,
87                                 ViewUnmap,
88                                 0,
89                                 PAGE_EXECUTE_READWRITE);
90     if (!NT_SUCCESS(Status))
91     {
92         DPRINT1("Couldn't map physical memory (%x)\n", Status);
93         ZwClose(PhysMemHandle);
94         return Status;
95     }
96 
97     /* Close physical memory section handle */
98     ZwClose(PhysMemHandle);
99 
100     if (BaseAddress != (PVOID)0xa0000)
101     {
102         DPRINT1("Couldn't map physical memory at the right address (was %x)\n",
103                 BaseAddress);
104         return STATUS_UNSUCCESSFUL;
105     }
106 
107     /* Allocate some low memory to use for the non-BIOS
108      * parts of the v86 mode address space
109      */
110     BaseAddress = (PVOID)0x1;
111     ViewSize = 0xa0000 - 0x1000;
112     Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
113                                      &BaseAddress,
114                                      0,
115                                      &ViewSize,
116                                      MEM_RESERVE | MEM_COMMIT,
117                                      PAGE_EXECUTE_READWRITE);
118     if (!NT_SUCCESS(Status))
119     {
120         DPRINT1("Failed to allocate virtual memory (Status %x)\n", Status);
121         return Status;
122     }
123     if (BaseAddress != (PVOID)0x0)
124     {
125         DPRINT1("Failed to allocate virtual memory at right address (was %x)\n",
126                 BaseAddress);
127         return 0;
128     }
129 
130 #ifdef _M_IX86
131     /* Get the real mode IVT and BDA from the kernel */
132     Status = NtVdmControl(VdmInitialize, IVTAndBda);
133     if (!NT_SUCCESS(Status))
134     {
135         DPRINT1("NtVdmControl failed (status %x)\n", Status);
136         return Status;
137     }
138 #endif // _M_IX86
139 
140     /* Return success */
141     return STATUS_SUCCESS;
142 }
143 #else
144 NTSTATUS
145 NTAPI
146 IntInitializeVideoAddressSpace(VOID)
147 {
148     UNIMPLEMENTED;
149     NT_ASSERT(FALSE);
150     return STATUS_NOT_IMPLEMENTED;
151 }
152 #endif
153 
154 VP_STATUS
155 NTAPI
156 IntInt10AllocateBuffer(
157     IN PVOID Context,
158     OUT PUSHORT Seg,
159     OUT PUSHORT Off,
160     IN OUT PULONG Length)
161 {
162     NTSTATUS Status;
163 #ifdef _M_IX86
164     PVOID MemoryAddress;
165     PKPROCESS CallingProcess = (PKPROCESS)PsGetCurrentProcess();
166     KAPC_STATE ApcState;
167     SIZE_T Size;
168 
169     TRACE_(VIDEOPRT, "IntInt10AllocateBuffer\n");
170 
171     IntAttachToCSRSS(&CallingProcess, &ApcState);
172 
173     Size = *Length;
174     MemoryAddress = (PVOID)0x20000;
175     Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
176                                      &MemoryAddress,
177                                      0,
178                                      &Size,
179                                      MEM_COMMIT,
180                                      PAGE_EXECUTE_READWRITE);
181     if (!NT_SUCCESS(Status))
182     {
183         WARN_(VIDEOPRT, "- ZwAllocateVirtualMemory failed\n");
184         IntDetachFromCSRSS(&CallingProcess, &ApcState);
185         return ERROR_NOT_ENOUGH_MEMORY;
186     }
187 
188     if (MemoryAddress > (PVOID)(0x100000 - Size))
189     {
190         ZwFreeVirtualMemory(NtCurrentProcess(),
191                             &MemoryAddress,
192                             &Size,
193                             MEM_RELEASE);
194         WARN_(VIDEOPRT, "- Unacceptable memory allocated\n");
195         IntDetachFromCSRSS(&CallingProcess, &ApcState);
196         return ERROR_NOT_ENOUGH_MEMORY;
197     }
198 
199     *Length = (ULONG)Size;
200     *Seg = (USHORT)((ULONG_PTR)MemoryAddress >> 4);
201     *Off = (USHORT)((ULONG_PTR)MemoryAddress & 0xF);
202 
203     INFO_(VIDEOPRT, "- Segment: %x\n", (ULONG_PTR)MemoryAddress >> 4);
204     INFO_(VIDEOPRT, "- Offset: %x\n", (ULONG_PTR)MemoryAddress & 0xF);
205     INFO_(VIDEOPRT, "- Length: %x\n", *Length);
206 
207     IntDetachFromCSRSS(&CallingProcess, &ApcState);
208 
209     return NO_ERROR;
210 #else
211     Status = x86BiosAllocateBuffer(Length, Seg, Off);
212     return NT_SUCCESS(Status) ? NO_ERROR : ERROR_NOT_ENOUGH_MEMORY;
213 #endif
214 }
215 
216 VP_STATUS
217 NTAPI
218 IntInt10FreeBuffer(
219     IN PVOID Context,
220     IN USHORT Seg,
221     IN USHORT Off)
222 {
223     NTSTATUS Status;
224 #ifdef _M_IX86
225     PVOID MemoryAddress = (PVOID)((ULONG_PTR)(Seg << 4) | Off);
226     PKPROCESS CallingProcess = (PKPROCESS)PsGetCurrentProcess();
227     KAPC_STATE ApcState;
228     SIZE_T Size = 0;
229 
230     TRACE_(VIDEOPRT, "IntInt10FreeBuffer\n");
231     INFO_(VIDEOPRT, "- Segment: %x\n", Seg);
232     INFO_(VIDEOPRT, "- Offset: %x\n", Off);
233 
234     IntAttachToCSRSS(&CallingProcess, &ApcState);
235     Status = ZwFreeVirtualMemory(NtCurrentProcess(),
236                                  &MemoryAddress,
237                                  &Size,
238                                  MEM_RELEASE);
239 
240     IntDetachFromCSRSS(&CallingProcess, &ApcState);
241 
242     return Status;
243 #else
244     Status = x86BiosFreeBuffer(Seg, Off);
245     return NT_SUCCESS(Status) ? NO_ERROR : ERROR_INVALID_PARAMETER;
246 #endif
247 }
248 
249 VP_STATUS
250 NTAPI
251 IntInt10ReadMemory(
252     IN PVOID Context,
253     IN USHORT Seg,
254     IN USHORT Off,
255     OUT PVOID Buffer,
256     IN ULONG Length)
257 {
258 #ifdef _M_IX86
259     PKPROCESS CallingProcess = (PKPROCESS)PsGetCurrentProcess();
260     KAPC_STATE ApcState;
261 
262     TRACE_(VIDEOPRT, "IntInt10ReadMemory\n");
263     INFO_(VIDEOPRT, "- Segment: %x\n", Seg);
264     INFO_(VIDEOPRT, "- Offset: %x\n", Off);
265     INFO_(VIDEOPRT, "- Buffer: %x\n", Buffer);
266     INFO_(VIDEOPRT, "- Length: %x\n", Length);
267 
268     IntAttachToCSRSS(&CallingProcess, &ApcState);
269     RtlCopyMemory(Buffer, (PVOID)((ULONG_PTR)(Seg << 4) | Off), Length);
270     IntDetachFromCSRSS(&CallingProcess, &ApcState);
271 
272     return NO_ERROR;
273 #else
274     NTSTATUS Status;
275 
276     Status = x86BiosReadMemory(Seg, Off, Buffer, Length);
277     return NT_SUCCESS(Status) ? NO_ERROR : ERROR_INVALID_PARAMETER;
278 #endif
279 }
280 
281 VP_STATUS
282 NTAPI
283 IntInt10WriteMemory(
284     IN PVOID Context,
285     IN USHORT Seg,
286     IN USHORT Off,
287     IN PVOID Buffer,
288     IN ULONG Length)
289 {
290 #ifdef _M_IX86
291     PKPROCESS CallingProcess = (PKPROCESS)PsGetCurrentProcess();
292     KAPC_STATE ApcState;
293 
294     TRACE_(VIDEOPRT, "IntInt10WriteMemory\n");
295     INFO_(VIDEOPRT, "- Segment: %x\n", Seg);
296     INFO_(VIDEOPRT, "- Offset: %x\n", Off);
297     INFO_(VIDEOPRT, "- Buffer: %x\n", Buffer);
298     INFO_(VIDEOPRT, "- Length: %x\n", Length);
299 
300     IntAttachToCSRSS(&CallingProcess, &ApcState);
301     RtlCopyMemory((PVOID)((ULONG_PTR)(Seg << 4) | Off), Buffer, Length);
302     IntDetachFromCSRSS(&CallingProcess, &ApcState);
303 
304     return NO_ERROR;
305 #else
306     NTSTATUS Status;
307 
308     Status = x86BiosWriteMemory(Seg, Off, Buffer, Length);
309     return NT_SUCCESS(Status) ? NO_ERROR : ERROR_INVALID_PARAMETER;
310 #endif
311 }
312 
313 VP_STATUS
314 NTAPI
315 IntInt10CallBios(
316     IN PVOID Context,
317     IN OUT PINT10_BIOS_ARGUMENTS BiosArguments)
318 {
319 #ifdef _M_AMD64
320     X86_BIOS_REGISTERS BiosContext;
321 #else
322     CONTEXT BiosContext;
323 #endif
324     NTSTATUS Status;
325     PKPROCESS CallingProcess = (PKPROCESS)PsGetCurrentProcess();
326     KAPC_STATE ApcState;
327 
328     /* Attach to CSRSS */
329     IntAttachToCSRSS(&CallingProcess, &ApcState);
330 
331     /* Clear the context */
332     RtlZeroMemory(&BiosContext, sizeof(BiosContext));
333 
334     /* Fill out the bios arguments */
335     BiosContext.Eax = BiosArguments->Eax;
336     BiosContext.Ebx = BiosArguments->Ebx;
337     BiosContext.Ecx = BiosArguments->Ecx;
338     BiosContext.Edx = BiosArguments->Edx;
339     BiosContext.Esi = BiosArguments->Esi;
340     BiosContext.Edi = BiosArguments->Edi;
341     BiosContext.Ebp = BiosArguments->Ebp;
342     BiosContext.SegDs = BiosArguments->SegDs;
343     BiosContext.SegEs = BiosArguments->SegEs;
344 
345     /* Do the ROM BIOS call */
346     (void)KeWaitForMutexObject(&VideoPortInt10Mutex,
347                                Executive,
348                                KernelMode,
349                                FALSE,
350                                NULL);
351 
352 #ifdef _M_AMD64
353     Status = x86BiosCall(0x10, &BiosContext) ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
354 #else
355     Status = Ke386CallBios(0x10, &BiosContext);
356 #endif
357 
358     KeReleaseMutex(&VideoPortInt10Mutex, FALSE);
359 
360     /* Return the arguments */
361     BiosArguments->Eax = BiosContext.Eax;
362     BiosArguments->Ebx = BiosContext.Ebx;
363     BiosArguments->Ecx = BiosContext.Ecx;
364     BiosArguments->Edx = BiosContext.Edx;
365     BiosArguments->Esi = BiosContext.Esi;
366     BiosArguments->Edi = BiosContext.Edi;
367     BiosArguments->Ebp = BiosContext.Ebp;
368     BiosArguments->SegDs = (USHORT)BiosContext.SegDs;
369     BiosArguments->SegEs = (USHORT)BiosContext.SegEs;
370 
371     /* Detach and return status */
372     IntDetachFromCSRSS(&CallingProcess, &ApcState);
373 
374     if (NT_SUCCESS(Status))
375     {
376         return NO_ERROR;
377     }
378 
379     return ERROR_INVALID_PARAMETER;
380 }
381 
382 /* PUBLIC FUNCTIONS ***********************************************************/
383 
384 /*
385  * @implemented
386  */
387 VP_STATUS
388 NTAPI
389 VideoPortInt10(
390     IN PVOID HwDeviceExtension,
391     IN PVIDEO_X86_BIOS_ARGUMENTS BiosArguments)
392 {
393     INT10_BIOS_ARGUMENTS Int10BiosArguments;
394     VP_STATUS Status;
395 
396     if (!CsrssInitialized)
397     {
398         return ERROR_INVALID_PARAMETER;
399     }
400 
401     /* Copy arguments to other format */
402     RtlCopyMemory(&Int10BiosArguments, BiosArguments, sizeof(*BiosArguments));
403     Int10BiosArguments.SegDs = 0;
404     Int10BiosArguments.SegEs = 0;
405 
406     /* Do the BIOS call */
407     Status = IntInt10CallBios(NULL, &Int10BiosArguments);
408 
409     /* Copy results back */
410     RtlCopyMemory(BiosArguments, &Int10BiosArguments, sizeof(*BiosArguments));
411 
412     return Status;
413 }
414