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