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