win32ss/drivers/videoprt/int10.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 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 }