reactos/drivers/dd/vga/miniport/vgamp.c

   1 /*
   2  * VGA.C - a generic VGA miniport driver
   3  *
   4  */
   5
   6 #include <ddk/ntddk.h>
   7 #include <ddk/ntddvid.h>
   8
   9 #define UNIMPLEMENTED do {DbgPrint("%s:%d: Function not implemented", __FILE__, __LINE__); for(;;);} while (0)
  10
  11 #define VERSION "0.0.0"
  12
  13 //  ----------------------------------------------------  Forward Declarations
  14 static VP_STATUS VGAFindAdapter(PVOID  DeviceExtension,
  15                                 PVOID  Context,
  16                                 PWSTR  ArgumentString,
  17                                 PVIDEO_PORT_CONFIG_INFO  ConfigInfo,
  18                                 PUCHAR  Again);
  19 static BOOLEAN VGAInitialize(PVOID  DeviceExtension);
  20 static BOOLEAN VGAStartIO(PVOID  DeviceExtension,
  21                           PVIDEO_REQUEST_PACKET  RequestPacket);
  22 /*
  23 static BOOLEAN VGAInterrupt(PVOID  DeviceExtension);
  24 static BOOLEAN VGAResetHw(PVOID  DeviceExtension,
  25                           ULONG  Columns,
  26                           ULONG  Rows);
  27 static VOID VGATimer(PVOID  DeviceExtension);
  28 */
  29
  30 /*  Mandatory IoControl routines  */
  31 VOID  VGAMapVideoMemory(IN PVIDEO_MEMORY  RequestedAddress,
  32                         OUT PVIDEO_MEMORY_INFORMATION  MapInformation,
  33                         OUT PSTATUS_BLOCK  StatusBlock);
  34 VOID  VGAQueryAvailModes(OUT PVIDEO_MODE_INFORMATION  ReturnedModes,
  35                          OUT PSTATUS_BLOCK  StatusBlock);
  36 VOID  VGAQueryCurrentMode(OUT PVIDEO_MODE_INFORMATION  CurrentMode,
  37                           OUT PSTATUS_BLOCK  StatusBlock);
  38 VOID  VGAQueryNumAvailModes(OUT PVIDEO_NUM_MODES  NumberOfModes,
  39                             OUT PSTATUS_BLOCK  StatusBlock);
  40 VOID  VGAResetDevice(OUT PSTATUS_BLOCK  StatusBlock);
  41 VOID  VGASetColorRegisters(IN PVIDEO_CLUT  ColorLookUpTable,
  42                            OUT PSTATUS_BLOCK  StatusBlock);
  43 VOID  VGASetPaletteRegisters(IN PWORD  PaletteRegisters,
  44                              OUT PSTATUS_BLOCK  StatusBlock);
  45 VOID  VGASetCurrentMode(IN PVIDEO_MODE  RequestedMode,
  46                         OUT PSTATUS_BLOCK  StatusBlock);
  47 VOID  VGAShareVideoMemory(IN PVIDEO_SHARE_MEMORY  RequestedMemory,
  48                           OUT PVIDEO_MEMORY_INFORMATION  ReturnedMemory,
  49                           OUT PSTATUS_BLOCK  StatusBlock);
  50 VOID  VGAUnmapVideoMemory(IN PVIDEO_MEMORY  MemoryToUnmap,
  51                           OUT PSTATUS_BLOCK  StatusBlock);
  52 VOID  VGAUnshareVideoMemory(IN PVIDEO_MEMORY  MemoryToUnshare,
  53                             OUT PSTATUS_BLOCK  StatusBlock);
  54
  55 //  -------------------------------------------------------  Public Interface
  56
  57 //    DriverEntry
  58 //
  59 //  DESCRIPTION:
  60 //    This function initializes the driver.
  61 //
  62 //  RUN LEVEL:
  63 //    PASSIVE_LEVEL
  64 //
  65 //  ARGUMENTS:
  66 //    IN  PVOID  Context1  Context parameter to pass to VidPortInitialize
  67 //    IN  PVOID  Context2  Context parameter to pass to VidPortInitialize
  68 //  RETURNS:
  69 //    VP_STATUS
  70
  71 VP_STATUS STDCALL
  72 DriverEntry(IN PVOID Context1,
  73             IN PVOID Context2)
  74 {
  75   VIDEO_HW_INITIALIZATION_DATA  InitData;
  76
  77   DbgPrint("VGA miniport Driver %s\n", VERSION);
  78
  79   VideoPortZeroMemory(&InitData, sizeof InitData);
  80
  81   /* FIXME: Fill in InitData members  */
  82   InitData.StartingDeviceNumber = 0;
  83
  84   /*  Export driver entry points...  */
  85   InitData.HwFindAdapter = VGAFindAdapter;
  86   InitData.HwInitialize = VGAInitialize;
  87   InitData.HwStartIO = VGAStartIO;
  88   /* InitData.HwInterrupt = VGAInterrupt;  */
  89   /* InitData.HwResetHw = VGAResetHw;  */
  90   /* InitData.HwTimer = VGATimer;  */
  91
  92   return  VideoPortInitialize(Context1, Context2, &InitData, NULL);
  93 }
  94
  95 //    VGAFindAdapter
  96 //
  97 //  DESCRIPTION:
  98 //    This routine is called by the videoport driver to find and allocate
  99 //    the adapter for a given bus.  The miniport driver needs to do the
 100 //    following in this routine:
 101 //      - Determine if the adapter is present
 102 //      - Claim any necessary memory/IO resources for the adapter
 103 //      - Map resources into system memory for the adapter
 104 //      - fill in relevant information in the VIDEO_PORT_CONFIG_INFO buffer
 105 //      - update registry settings for adapter specifics.
 106 //      - Set 'Again' based on whether the function should be called again
 107 //        another adapter on the same bus.
 108 //
 109 //  RUN LEVEL:
 110 //    PASSIVE_LEVEL
 111 //
 112 //  ARGUMENTS:
 113 //    PVOID                    DeviceExtension
 114 //    PVOID                    Context
 115 //    PWSTR                    ArgumentString
 116 //    PVIDEO_PORT_CONFIG_INFO  ConfigInfo
 117 //    PUCHAR                   Again
 118 //  RETURNS:
 119 //    VP_STATUS
 120
 121 static VP_STATUS
 122 VGAFindAdapter(PVOID  DeviceExtension,
 123                PVOID  Context,
 124                PWSTR  ArgumentString,
 125                PVIDEO_PORT_CONFIG_INFO  ConfigInfo,
 126                PUCHAR  Again)
 127 {
 128   /* FIXME: Determine if the adapter is present  */
 129   *Again = FALSE;
 130
 131   return  STATUS_SUCCESS;
 132
 133   /* FIXME: Claim any necessary memory/IO resources for the adapter  */
 134   /* FIXME: Map resources into system memory for the adapter  */
 135   /* FIXME: Fill in relevant information in the VIDEO_PORT_CONFIG_INFO buffer  */
 136   /* FIXME: Update registry settings for adapter specifics.  */
 137 //  return  NO_ERROR;
 138 }
 139
 140 //    VGAInitialize
 141 //
 142 //  DESCRIPTION:
 143 //    Perform initialization tasks, but leave the adapter in the same
 144 //    user visible state
 145 //
 146 //  RUN LEVEL:
 147 //    PASSIVE_LEVEL
 148 //
 149 //  ARGUMENTS:
 150 //    PVOID  DeviceExtension
 151 //  RETURNS:
 152 //    BOOLEAN  Success or failure
 153 static BOOLEAN
 154 VGAInitialize(PVOID  DeviceExtension)
 155 {
 156   return  FALSE;
 157 }
 158
 159 //    VGAStartIO
 160 //
 161 //  DESCRIPTION:
 162 //    This function gets called in responce to GDI EngDeviceIoControl
 163 //    calls.  Device requests are passed in VRPs.
 164 //      Required VRPs:
 165 //        IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES
 166 //        IOCTL_VIDEO_QUERY_AVAIL_MODES
 167 //        IOCTL_VIDEO_QUERY_CURRENT_MODE
 168 //        IOCTL_VIDEO_SET_CURRENT_MODE
 169 //        IOCTL_VIDEO_RESET_DEVICE
 170 //        IOCTL_VIDEO_MAP_VIDEO_MEMORY
 171 //        IOCTL_VIDEO_UNMAP_VIDEO_MEMORY
 172 //        IOCTL_VIDEO_SHARE_VIDEO_MEMORY
 173 //        IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY
 174 //      Optional VRPs:
 175 //        IOCTL_VIDEO_GET_PUBLIC_ACCESS_RANGES
 176 //        IOCTL_VIDEO_FREE_PUBLIC_ACCESS_RANGES
 177 //        IOCTL_VIDEO_GET_POWER_MANAGEMENT
 178 //        IOCTL_VIDEO_SET_POWER_MANAGEMENT
 179 //        IOCTL_QUERY_COLOR_CAPABILITIES
 180 //        IOCTL_VIDEO_SET_COLOR_REGISTERS (required if the device has a palette)
 181 //        IOCTL_VIDEO_DISABLE_POINTER
 182 //        IOCTL_VIDEO_ENABLE_POINTER
 183 //        IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES
 184 //        IOCTL_VIDEO_QUERY_POINTER_ATTR
 185 //        IOCTL_VIDEO_SET_POINTER_ATTR
 186 //        IOCTL_VIDEO_QUERY_POINTER_POSITION
 187 //        IOCTL_VIDEO_SET_POINTER_POSITION
 188 //        IOCTL_VIDEO_SAVE_HARDWARE_STATE
 189 //        IOCTL_VIDEO_RESTORE_HARDWARE_STATE
 190 //        IOCTL_VIDEO_DISABLE_CURSOR
 191 //        IOCTL_VIDEO_ENABLE_CURSOR
 192 //        IOCTL_VIDEO_QUERY_CURSOR_ATTR
 193 //        IOCTL_VIDEO_SET_CURSOR_ATTR
 194 //        IOCTL_VIDEO_QUERY_CURSOR_POSITION
 195 //        IOCTL_VIDEO_SET_CURSOR_POSITION
 196 //        IOCTL_VIDEO_GET_BANK_SELECT_CODE
 197 //        IOCTL_VIDEO_SET_PALETTE_REGISTERS
 198 //        IOCTL_VIDEO_LOAD_AND_SET_FONT
 199 //
 200 //  RUN LEVEL:
 201 //    PASSIVE_LEVEL
 202 //
 203 //  ARGUMENTS:
 204 //    PVOID                  DeviceExtension
 205 //    PVIDEO_REQUEST_PACKET  RequestPacket
 206 //  RETURNS:
 207 //    BOOLEAN  This function must return TRUE, and complete the work or
 208 //             set an error status in the VRP.
 209
 210 static BOOLEAN
 211 VGAStartIO(PVOID  DeviceExtension,
 212            PVIDEO_REQUEST_PACKET  RequestPacket)
 213 {
 214   switch (RequestPacket->IoControlCode)
 215     {
 216     case  IOCTL_VIDEO_MAP_VIDEO_MEMORY:
 217       VGAMapVideoMemory((PVIDEO_MEMORY) RequestPacket->InputBuffer,
 218                         (PVIDEO_MEMORY_INFORMATION)
 219                           RequestPacket->OutputBuffer,
 220                         &RequestPacket->StatusBlock);
 221       break;
 222
 223     case  IOCTL_VIDEO_QUERY_AVAIL_MODES:
 224       VGAQueryAvailModes((PVIDEO_MODE_INFORMATION) RequestPacket->OutputBuffer,
 225                          &RequestPacket->StatusBlock);
 226       break;
 227
 228     case  IOCTL_VIDEO_QUERY_CURRENT_MODE:
 229       VGAQueryCurrentMode((PVIDEO_MODE_INFORMATION) RequestPacket->OutputBuffer,
 230                           &RequestPacket->StatusBlock);
 231       break;
 232
 233     case  IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES:
 234       VGAQueryNumAvailModes((PVIDEO_NUM_MODES) RequestPacket->OutputBuffer,
 235                             &RequestPacket->StatusBlock);
 236       break;
 237
 238     case  IOCTL_VIDEO_RESET_DEVICE:
 239       VGAResetDevice(&RequestPacket->StatusBlock);
 240       break;
 241
 242     case  IOCTL_VIDEO_SET_COLOR_REGISTERS:
 243       VGASetColorRegisters((PVIDEO_CLUT) RequestPacket->InputBuffer,
 244                            &RequestPacket->StatusBlock);
 245       break;
 246
 247     case  IOCTL_VIDEO_SET_CURRENT_MODE:
 248       VGASetCurrentMode((PVIDEO_MODE) RequestPacket->InputBuffer,
 249                         &RequestPacket->StatusBlock);
 250       break;
 251
 252     case  IOCTL_VIDEO_SHARE_VIDEO_MEMORY:
 253       VGAShareVideoMemory((PVIDEO_SHARE_MEMORY) RequestPacket->InputBuffer,
 254                           (PVIDEO_MEMORY_INFORMATION) RequestPacket->OutputBuffer,
 255                           &RequestPacket->StatusBlock);
 256       break;
 257
 258     case  IOCTL_VIDEO_UNMAP_VIDEO_MEMORY:
 259       VGAUnmapVideoMemory((PVIDEO_MEMORY) RequestPacket->InputBuffer,
 260                           &RequestPacket->StatusBlock);
 261       break;
 262
 263     case  IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY:
 264       VGAUnshareVideoMemory((PVIDEO_MEMORY) RequestPacket->InputBuffer,
 265                             &RequestPacket->StatusBlock);
 266       break;
 267     case  IOCTL_VIDEO_SET_PALETTE_REGISTERS:
 268       VGASetPaletteRegisters((PVIDEO_CLUT) RequestPacket->InputBuffer,
 269                            &RequestPacket->StatusBlock);
 270       break;
 271
 272 #if 0
 273     case  IOCTL_VIDEO_DISABLE_CURSOR:
 274     case  IOCTL_VIDEO_DISABLE_POINTER:
 275     case  IOCTL_VIDEO_ENABLE_CURSOR:
 276     case  IOCTL_VIDEO_ENABLE_POINTER:
 277
 278     case  IOCTL_VIDEO_FREE_PUBLIC_ACCESS_RANGES:
 279       VGAFreePublicAccessRanges((PVIDEO_PUBLIC_ACCESS_RANGES)
 280                                   RequestPacket->InputBuffer,
 281                                 &RequestPacket->StatusBlock);
 282       break;
 283
 284     case  IOCTL_VIDEO_GET_BANK_SELECT_CODE:
 285     case  IOCTL_VIDEO_GET_POWER_MANAGEMENT:
 286     case  IOCTL_VIDEO_LOAD_AND_SET_FONT:
 287     case  IOCTL_VIDEO_QUERY_CURSOR_POSITION:
 288     case  IOCTL_VIDEO_QUERY_COLOR_CAPABILITIES:
 289     case  IOCTL_VIDEO_QUERY_CURSOR_ATTR:
 290     case  IOCTL_VIDEO_QUERY_POINTER_ATTR:
 291     case  IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES:
 292     case  IOCTL_VIDEO_QUERY_POINTER_POSITION:
 293
 294     case  IOCTL_VIDEO_QUERY_PUBLIC_ACCESS_RANGES:
 295       VGAQueryPublicAccessRanges((PVIDEO_PUBLIC_ACCESS_RANGES)
 296                                    RequestPacket->OutputBuffer,
 297                                  &RequestPacket->StatusBlock);
 298       break;
 299
 300     case  IOCTL_VIDEO_RESTORE_HARDWARE_STATE:
 301     case  IOCTL_VIDEO_SAVE_HARDWARE_STATE:
 302     case  IOCTL_VIDEO_SET_CURSOR_ATTR:
 303     case  IOCTL_VIDEO_SET_CURSOR_POSITION:
 304     case  IOCTL_VIDEO_SET_POINTER_ATTR:
 305     case  IOCTL_VIDEO_SET_POINTER_POSITION:
 306     case  IOCTL_VIDEO_SET_POWER_MANAGEMENT:
 307
 308 #endif
 309
 310     default:
 311       RequestPacket->StatusBlock->Status = STATUS_NOT_IMPLEMENTED;
 312       break;
 313     }
 314
 315   return TRUE;
 316 }
 317
 318 #if 0
 319 //    VGAInterrupt
 320 //
 321 //  DESCRIPTION:
 322 //    This function will be called upon receipt of a adapter generated
 323 //    interrupt when enabled.
 324 //
 325 //  RUN LEVEL:
 326 //    IRQL
 327 //
 328 //  ARGUMENTS:
 329 //    PVOID                  DeviceExtension
 330 //  RETURNS:
 331 //    BOOLEAN  TRUE if the interrupt was handled by the routine
 332
 333 static BOOLEAN VGAInterrupt(PVOID  DeviceExtension);
 334
 335 //    VGAResetHw
 336 //
 337 //  DESCRIPTION:
 338 //    This function is called to reset the hardware to a known state
 339 //    if calling a BIOS int 10 reset will not achieve this result.
 340 //
 341 //  RUN LEVEL:
 342 //    PASSIVE_LEVEL
 343 //
 344 //  ARGUMENTS:
 345 //    PVOID  DeviceExtension
 346 //    ULONG  Columns          Columns and Rows specify the mode parameters
 347 //    ULONG  Rows               to reset to.
 348 //  RETURNS:
 349 //    BOOLEAN  TRUE if no further action is necessary, FALSE if the system
 350 //             needs to still do a BOIS int 10 reset.
 351
 352 static BOOLEAN VGAResetHw(PVOID  DeviceExtension,
 353                           ULONG  Columns,
 354                           ULONG  Rows);
 355
 356 //    VGATimer
 357 //
 358 //  DESCRIPTION:
 359 //    This function will be called once a second when enabled
 360 //
 361 //  RUN LEVEL:
 362 //    PASSIVE_LEVEL
 363 //
 364 //  ARGUMENTS:
 365 //    PVOID  DeviceExtension
 366 //  RETURNS:
 367 //    VOID
 368
 369 static VOID VGATimer(PVOID  DeviceExtension);
 370
 371 #endif
 372
 373 VOID  VGAMapVideoMemory(IN PVIDEO_MEMORY  RequestedAddress,
 374                         OUT PVIDEO_MEMORY_INFORMATION  MapInformation,
 375                         OUT PSTATUS_BLOCK  StatusBlock)
 376 {
 377   UNIMPLEMENTED;
 378 }
 379
 380 VOID  VGAQueryAvailModes(OUT PVIDEO_MODE_INFORMATION  ReturnedModes,
 381                          OUT PSTATUS_BLOCK  StatusBlock)
 382 {
 383   UNIMPLEMENTED;
 384 }
 385
 386 VOID  VGAQueryCurrentMode(OUT PVIDEO_MODE_INFORMATION  CurrentMode,
 387                           OUT PSTATUS_BLOCK  StatusBlock)
 388 {
 389   UNIMPLEMENTED;
 390 }
 391
 392 VOID  VGAQueryNumAvailModes(OUT PVIDEO_NUM_MODES  NumberOfModes,
 393                             OUT PSTATUS_BLOCK  StatusBlock)
 394 {
 395   UNIMPLEMENTED;
 396 }
 397
 398 VOID  VGASetPaletteRegisters(IN PWORD  PaletteRegisters,
 399                              OUT PSTATUS_BLOCK  StatusBlock)
 400 {
 401   ;
 402
 403 /*
 404   We don't need the following code because the palette registers are set correctly on VGA initialization.
 405   Still, we may include\test this is in the future.
 406
 407   int i, j = 2;
 408   char tmp, v;
 409
 410   tmp = VideoPortReadPortUchar(0x03da);
 411   v = VideoPortReadPortUchar(0x03c0);
 412
 413   // Set the first 16 palette registers to map to the first 16 palette colors
 414   for (i=PaletteRegisters[1]; i<PaletteRegisters[0]; i++)
 415   {
 416     tmp = VideoPortReadPortUchar(0x03da);
 417     VideoPortWritePortUchar(0x03c0, i);
 418     VideoPortWritePortUchar(0x03c0, PaletteRegisters[j++]);
 419   }
 420
 421   tmp = VideoPortReadPortUchar(0x03da);
 422   VideoPortWritePortUchar(0x03d0, v | 0x20);
 423 */
 424 }
 425
 426 VOID  VGASetColorRegisters(IN PVIDEO_CLUT  ColorLookUpTable,
 427                            OUT PSTATUS_BLOCK  StatusBlock)
 428 {
 429   int i;
 430
 431   for (i=ColorLookUpTable->FirstEntry; i<ColorLookUpTable->NumEntries; i++)
 432   {
 433     VideoPortWritePortUchar(0x03c8, i);
 434     VideoPortWritePortUchar(0x03c9, ColorLookUpTable->LookupTable[i].RgbArray.Red);
 435     VideoPortWritePortUchar(0x03c9, ColorLookUpTable->LookupTable[i].RgbArray.Green);
 436     VideoPortWritePortUchar(0x03c9, ColorLookUpTable->LookupTable[i].RgbArray.Blue);
 437   }
 438 }
 439
 440 VOID  VGASetCurrentMode(IN PVIDEO_MODE  RequestedMode,
 441                         OUT PSTATUS_BLOCK  StatusBlock)
 442 {
 443   if(RequestedMode->RequestedMode == 12)
 444   {
 445     InitVGAMode();
 446   } else {
 447     DbgPrint("Unrecognised mode for VGASetCurrentMode\n");
 448   }
 449 }
 450
 451 VOID  VGAShareVideoMemory(IN PVIDEO_SHARE_MEMORY  RequestedMemory,
 452                           OUT PVIDEO_MEMORY_INFORMATION  ReturnedMemory,
 453                           OUT PSTATUS_BLOCK  StatusBlock)
 454 {
 455   UNIMPLEMENTED;
 456 }
 457
 458 VOID  VGAUnmapVideoMemory(IN PVIDEO_MEMORY  MemoryToUnmap,
 459                           OUT PSTATUS_BLOCK  StatusBlock)
 460 {
 461   UNIMPLEMENTED;
 462 }
 463
 464 VOID  VGAUnshareVideoMemory(IN PVIDEO_MEMORY  MemoryToUnshare,
 465                             OUT PSTATUS_BLOCK  StatusBlock)
 466 {
 467   UNIMPLEMENTED;
 468 }