![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bank.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga|
Return to bank.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga |
1.1 ! root 1: /******************************Module*Header*******************************\ ! 2: * Module Name: bank.c ! 3: * ! 4: * Functions to control VGA banking ! 5: * ! 6: * Copyright (c) 1992 Microsoft Corporation ! 7: \**************************************************************************/ ! 8: ! 9: ! 10: #include "driver.h" // private driver defines ! 11: ! 12: void BankErrorTrap(PDEVSURF, LONG, BANK_JUST); ! 13: void Bank2Window(PDEVSURF, LONG, BANK_JUST, ULONG); ! 14: void Bank2Window2RW(PDEVSURF, LONG, BANK_JUST, ULONG); ! 15: void Bank2Window1RW(PDEVSURF, LONG, BANK_JUST, ULONG); ! 16: void Bank1Window2RW(PDEVSURF, LONG, BANK_JUST); ! 17: void Bank1Window(PDEVSURF, LONG, BANK_JUST); ! 18: ! 19: LPBYTE pPtrWork; ! 20: LPBYTE pPtrSave; ! 21: ! 22: // BUGBUG all routines should get the scan width out of the surface ! 23: ULONG ulNextScan_global; ! 24: ! 25: /******************************Public*Routine******************************\ ! 26: * SetUpBanking ! 27: * ! 28: * Set up banking for the current mode ! 29: * pdsurf and ppdev are the pointers to the current surface and device ! 30: * Relevant fields in the surface are set up for banking ! 31: \**************************************************************************/ ! 32: ! 33: BOOL SetUpBanking(PDEVSURF pdsurf, PPDEV ppdev) ! 34: { ! 35: INT i; ! 36: LONG lTemp; ! 37: LONG lScansPerBank, lScan, lTotalScans, lTotalBanks; ! 38: LONG lScansBetweenBanks; ! 39: ULONG ulOffset; ! 40: PVIDEO_BANK_SELECT BankInfo; ! 41: UINT ReturnedDataLength; ! 42: VIDEO_BANK_SELECT TempBankInfo; ! 43: PBANK_INFO pbiWorking; ! 44: ! 45: // ! 46: // Query the miniport for banking info for this mode. ! 47: // ! 48: // First, figure out how big a buffer we need for the banking info ! 49: // (returned in TempBankInfo->Size). ! 50: // ! 51: ! 52: // ! 53: // BUGBUG The error paths should point to the end of the function where ! 54: // we can deallocate all the buffers that were allocated. ! 55: // ! 56: ! 57: if (!DeviceIoControl(ppdev->hDriver, ! 58: IOCTL_VIDEO_GET_BANK_SELECT_CODE, ! 59: NULL, // input buffer ! 60: 0, ! 61: &TempBankInfo, // output buffer ! 62: sizeof(VIDEO_BANK_SELECT), ! 63: &ReturnedDataLength, ! 64: NULL)) { ! 65: ! 66: // ! 67: // We expect this call to fail, because we didn't allow any room ! 68: // for the code; we just want to get the required output buffer ! 69: // size. Make sure we got the expected error, ERROR_MORE_DATA. ! 70: // ! 71: ! 72: if (GetLastError() != ERROR_MORE_DATA) { ! 73: ! 74: // ! 75: // Should post error and return FALSE ! 76: // ! 77: ! 78: RIP("VGA.DLL: Initialization error-GetBankSelectCode, first call"); ! 79: ! 80: return FALSE; ! 81: } ! 82: ! 83: } ! 84: ! 85: ! 86: // ! 87: // Now, allocate a buffer of the required size and get the banking info. ! 88: // ! 89: ! 90: if ((BankInfo = (PVIDEO_BANK_SELECT) LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, ! 91: TempBankInfo.Size)) == NULL) { ! 92: ! 93: // ! 94: // Should post error and return FALSE ! 95: // ! 96: ! 97: RIP("VGA.DLL: Initialization error-couldn't get memory for bank info"); ! 98: return FALSE; ! 99: ! 100: ! 101: } ! 102: ! 103: if (!DeviceIoControl(ppdev->hDriver, ! 104: IOCTL_VIDEO_GET_BANK_SELECT_CODE, ! 105: NULL, ! 106: 0, ! 107: BankInfo, ! 108: TempBankInfo.Size, ! 109: &ReturnedDataLength, ! 110: NULL)) { ! 111: ! 112: // ! 113: // Should post error and return FALSE ! 114: // ! 115: ! 116: RIP("VGA.DLL: Initialization error-GetBankSelectCode, second call"); ! 117: return FALSE; ! 118: ! 119: } ! 120: ! 121: ! 122: // ! 123: // Set up for banking. ! 124: // ! 125: ! 126: // Set up variables that are the same whether the adapter is banked or not ! 127: ! 128: pdsurf->pBankSelectInfo = BankInfo; ! 129: pdsurf->pfnBankSwitchCode = ! 130: (PFN) (((UCHAR *)BankInfo) + BankInfo->CodeOffset); ! 131: pdsurf->vbtBankingType = BankInfo->BankingType; ! 132: pdsurf->ulBitmapSize = BankInfo->BitmapSize; ! 133: pdsurf->lNextScan = BankInfo->BitmapWidthInBytes; ! 134: ! 135: // BUGBUG this should not be static ! 136: ulNextScan_global = BankInfo->BitmapWidthInBytes; ! 137: ! 138: // Set up the pointer off-screen work areas at the very end of display ! 139: // memory (values are relative to bitmap start) ! 140: // BUGBUG should be in PDEV ! 141: pPtrWork = (LPBYTE) pdsurf->ulBitmapSize - POINTER_WORK_AREA_SIZE; ! 142: pPtrSave = pPtrWork - POINTER_SAVE_AREA_SIZE; ! 143: ! 144: // Set up info that depends on whether or not the adapter is banked ! 145: ! 146: if (BankInfo->BankingType == VideoNotBanked) { ! 147: ! 148: lTotalScans = BankInfo->BitmapSize / BankInfo->BitmapWidthInBytes; ! 149: ! 150: // Unbanked; set all clip rects for the full bitmap, so the bank never ! 151: // needs to be changed, and set the banking vectors to error traps, ! 152: // since they should never be called ! 153: ! 154: pdsurf->rcl1WindowClip.left = pdsurf->rcl2WindowClip[0].left = ! 155: pdsurf->rcl2WindowClip[1].left = pdsurf->rcl1WindowClip.top = ! 156: pdsurf->rcl2WindowClip[0].top = pdsurf->rcl2WindowClip[1].top = 0; ! 157: ! 158: pdsurf->rcl1WindowClip.right = pdsurf->rcl2WindowClip[0].right = ! 159: pdsurf->rcl2WindowClip[1].right = ! 160: BankInfo->BitmapWidthInBytes << 8; ! 161: ! 162: pdsurf->rcl1WindowClip.bottom = pdsurf->rcl2WindowClip[0].bottom = ! 163: pdsurf->rcl2WindowClip[1].bottom = lTotalScans; ! 164: ! 165: pdsurf->pfnBankControl = BankErrorTrap; ! 166: pdsurf->pfnBankControl2Window = BankErrorTrap; ! 167: ! 168: pdsurf->ulWindowBank[0] = pdsurf->ulWindowBank[1] = (ULONG)0; ! 169: pdsurf->pvBitmapStart = pdsurf->pvBitmapStart2Window[0] = ! 170: pdsurf->pvBitmapStart2Window[1] = pdsurf->pvStart; ! 171: ! 172: // Scan line to be used with JustifyBottom to map in the bank ! 173: // containing the pointer work and save areas, which are guaranteed not ! 174: // to span banks. Is only used to determine that the bank never needs ! 175: // to be changed to map in the pointer in unbanked case ! 176: pdsurf->ulPtrBankScan = 0; ! 177: ! 178: // Mark that the bank info pointers are unused, so we don't try to ! 179: // deallocate the memory they point to ! 180: pdsurf->pbiBankInfo = pdsurf->pbiBankInfo2RW = NULL; ! 181: ! 182: // Allocate space for the temp buffer. ! 183: ! 184: if ((pdsurf->pvBankBufferPlane0 = ! 185: (PVOID) LocalAlloc(LMEM_FIXED | ! 186: LMEM_ZEROINIT, BANK_BUFFER_SIZE_UNBANKED)) == NULL) { ! 187: ! 188: // ! 189: // Should post error and return FALSE ! 190: // ! 191: ! 192: RIP("VGA.DLL: Couldn't get memory for temp buffer"); ! 193: return FALSE; ! 194: ! 195: } ! 196: ! 197: pdsurf->ulTempBufferSize = BANK_BUFFER_SIZE_UNBANKED; ! 198: ! 199: // These should never be used ! 200: pdsurf->pvBankBufferPlane1 = ! 201: pdsurf->pvBankBufferPlane2 = ! 202: pdsurf->pvBankBufferPlane3 = (PVOID) NULL; ! 203: ! 204: } else { ! 205: ! 206: // Banked, so set up all banking variables and initialize the bank ! 207: // control routines and their data tables ! 208: ! 209: // Reject if there are broken rasters (a broken raster is a scan line ! 210: // that crosses a bank boundary); that's not handled in this driver ! 211: ! 212: if (BankInfo->BankingType != VideoBanked2RW) { ! 213: ! 214: // For the 1 RW window and 1R1W window cases, windows are ! 215: // assumed to be BANK_SIZE_1_WINDOW in size (generally 64K) ! 216: lTemp = BANK_SIZE_1_WINDOW; ! 217: ! 218: } else { ! 219: ! 220: // For the 2 RW window case, windows are assumed to be ! 221: // BANK_SIZE_2RW_WINDOW in size (generally 32K) ! 222: lTemp = BANK_SIZE_2RW_WINDOW; ! 223: ! 224: } ! 225: ! 226: if ((lTemp % BankInfo->BitmapWidthInBytes) != 0) { ! 227: ! 228: // ! 229: // Should post error and return FALSE ! 230: // ! 231: ! 232: RIP("VGA.DLL: Broken rasters not supported"); ! 233: return FALSE; ! 234: ! 235: } ! 236: ! 237: // These will be set properly on first call to bank controller, below, ! 238: // or something's wrong ! 239: pdsurf->ulWindowBank[0] = (ULONG)-1; ! 240: pdsurf->ulWindowBank[1] = (ULONG)-1; ! 241: pdsurf->pvBitmapStart = pdsurf->pvBitmapStart2Window[0] = ! 242: pdsurf->pvBitmapStart2Window[1] = (PVOID) 0; ! 243: ! 244: // Set all clip rects to invalid; they'll be updated when the first ! 245: // bank is mapped in ! 246: ! 247: pdsurf->rcl1WindowClip.left = pdsurf->rcl2WindowClip[0].left = ! 248: pdsurf->rcl2WindowClip[1].left = pdsurf->rcl1WindowClip.top = ! 249: pdsurf->rcl2WindowClip[0].top = pdsurf->rcl2WindowClip[1].top = ! 250: pdsurf->rcl1WindowClip.right = pdsurf->rcl2WindowClip[0].right = ! 251: pdsurf->rcl2WindowClip[1].right = pdsurf->rcl1WindowClip.bottom = ! 252: pdsurf->rcl2WindowClip[0].bottom = ! 253: pdsurf->rcl2WindowClip[1].bottom = -1; ! 254: ! 255: // Set up to call the appropriate banking control routines ! 256: ! 257: switch(BankInfo->BankingType) { ! 258: ! 259: case VideoBanked1RW: ! 260: ! 261: pdsurf->pfnBankControl = Bank1Window; ! 262: pdsurf->pfnBankControl2Window = Bank2Window1RW; ! 263: ! 264: if ((pdsurf->pvBankBufferPlane0 = ! 265: (PVOID) LocalAlloc(LMEM_FIXED | ! 266: LMEM_ZEROINIT, BANK_BUFFER_SIZE_1RW)) == NULL) { ! 267: ! 268: // ! 269: // Should post error and return FALSE ! 270: // ! 271: ! 272: RIP("VGA.DLL: Couldn't get memory for temp buffer"); ! 273: return FALSE; ! 274: ! 275: } ! 276: ! 277: pdsurf->ulTempBufferSize = BANK_BUFFER_SIZE_1RW; ! 278: ! 279: pdsurf->pvBankBufferPlane1 = ! 280: ((LPBYTE)pdsurf->pvBankBufferPlane0) + ! 281: BANK_BUFFER_PLANE_SIZE; ! 282: pdsurf->pvBankBufferPlane2 = ! 283: ((LPBYTE)pdsurf->pvBankBufferPlane1) + ! 284: BANK_BUFFER_PLANE_SIZE; ! 285: pdsurf->pvBankBufferPlane3 = ! 286: ((LPBYTE)pdsurf->pvBankBufferPlane2) + ! 287: BANK_BUFFER_PLANE_SIZE; ! 288: ! 289: break; ! 290: ! 291: ! 292: case VideoBanked1R1W: ! 293: ! 294: pdsurf->pfnBankControl = Bank1Window; ! 295: pdsurf->pfnBankControl2Window = Bank2Window; ! 296: ! 297: if ((pdsurf->pvBankBufferPlane0 = ! 298: (PVOID) LocalAlloc(LMEM_FIXED | ! 299: LMEM_ZEROINIT, BANK_BUFFER_SIZE_1R1W)) == NULL) { ! 300: ! 301: // ! 302: // Should post error and return FALSE ! 303: // ! 304: ! 305: RIP("VGA.DLL: Couldn't get memory for temp buffer"); ! 306: return FALSE; ! 307: ! 308: } ! 309: ! 310: pdsurf->ulTempBufferSize = BANK_BUFFER_SIZE_1R1W; ! 311: ! 312: // These should never be used ! 313: pdsurf->pvBankBufferPlane1 = ! 314: pdsurf->pvBankBufferPlane2 = ! 315: pdsurf->pvBankBufferPlane3 = (PVOID) NULL; ! 316: ! 317: break; ! 318: ! 319: ! 320: case VideoBanked2RW: ! 321: ! 322: pdsurf->pfnBankControl = Bank1Window2RW; ! 323: pdsurf->pfnBankControl2Window = Bank2Window2RW; ! 324: ! 325: if ((pdsurf->pvBankBufferPlane0 = ! 326: (PVOID) LocalAlloc(LMEM_FIXED | ! 327: LMEM_ZEROINIT, BANK_BUFFER_SIZE_2RW)) == NULL) { ! 328: ! 329: // ! 330: // Should post error and return FALSE ! 331: // ! 332: ! 333: RIP("VGA.DLL: Couldn't get memory for temp buffer"); ! 334: return FALSE; ! 335: ! 336: } ! 337: ! 338: pdsurf->ulTempBufferSize = BANK_BUFFER_SIZE_2RW; ! 339: ! 340: // These should never be used ! 341: pdsurf->pvBankBufferPlane1 = ! 342: pdsurf->pvBankBufferPlane2 = ! 343: pdsurf->pvBankBufferPlane3 = (PVOID) NULL; ! 344: ! 345: break; ! 346: ! 347: default: ! 348: ! 349: // ! 350: // Should post error and return FALSE ! 351: // ! 352: ! 353: RIP("VGA.DLL: bad BankingType"); ! 354: return FALSE; ! 355: ! 356: } ! 357: ! 358: // Set up the bank control tables with clip rects for banks ! 359: // Note: lTotalBanks is generally an overestimate when granularity ! 360: // is less than window size, because we ignore any banks after the ! 361: // first one that includes the last scan line of the bitmap. A bit ! 362: // of memory could be saved by sizing lTotalBanks exactly. Note too, ! 363: // though, that the 2 RW window case may require more entries then, ! 364: // because its windows are shorter, so you'd have to make sure there ! 365: // were enough entries for the 2 RW window case, or recalculate ! 366: // lTotalBanks for the 2 RW case ! 367: ! 368: lTotalBanks = BankInfo->BitmapSize / BankInfo->Granularity; ! 369: lTotalScans = BankInfo->BitmapSize / BankInfo->BitmapWidthInBytes; ! 370: lScansBetweenBanks = ! 371: BankInfo->Granularity / BankInfo->BitmapWidthInBytes; ! 372: ! 373: // Allocate memory for bank control info ! 374: ! 375: if ((pdsurf->pbiBankInfo = (PBANK_INFO) LocalAlloc(LMEM_FIXED | ! 376: LMEM_ZEROINIT, lTotalBanks * sizeof(BANK_INFO))) == NULL) { ! 377: ! 378: // ! 379: // Should post error and return FALSE ! 380: // ! 381: ! 382: RIP("VGA.DLL: Couldn't get memory for bank info #2"); ! 383: return FALSE; ! 384: ! 385: } ! 386: ! 387: // Build the list of bank rects & offsets assuming standard window ! 388: // size ! 389: ! 390: lScansPerBank = BANK_SIZE_1_WINDOW / BankInfo->BitmapWidthInBytes; ! 391: ulOffset = 0; ! 392: lScan = -lScansBetweenBanks; // precompensate for 1st time in loop ! 393: i = 0; ! 394: pbiWorking = pdsurf->pbiBankInfo; ! 395: ! 396: do { ! 397: ! 398: lScan += lScansBetweenBanks; ! 399: pbiWorking->rclBankBounds.left = 0; ! 400: pbiWorking->rclBankBounds.right = pdsurf->sizlSurf.cx; ! 401: pbiWorking->rclBankBounds.top = lScan; ! 402: pbiWorking->rclBankBounds.bottom = lScan + lScansPerBank; ! 403: pbiWorking->ulBankOffset = ulOffset; ! 404: ulOffset += BankInfo->Granularity; ! 405: i++; ! 406: pbiWorking++; ! 407: ! 408: } while ((lScan + lScansPerBank) < lTotalScans); ! 409: ! 410: pdsurf->ulBankInfoLength = i; ! 411: ! 412: // If this is a 2RW bank adapter, build a table for that too, with ! 413: // 32K windows ! 414: ! 415: if (BankInfo->BankingType == VideoBanked2RW) { ! 416: ! 417: // Offset from one bank index to next to make two 32K banks ! 418: // appear to be one seamless 64K bank ! 419: pdsurf->ulBank2RWSkip = ! 420: (BANK_SIZE_2RW_WINDOW / BankInfo->Granularity); ! 421: ! 422: // Allocate memory for 2RW case bank control info ! 423: if ((pdsurf->pbiBankInfo2RW = ! 424: (PBANK_INFO) LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, ! 425: lTotalBanks * sizeof(BANK_INFO))) == NULL) { ! 426: ! 427: // ! 428: // Should post error and return FALSE ! 429: // ! 430: ! 431: RIP("VGA.DLL: Couldn't get memory for bank info #3"); ! 432: return FALSE; ! 433: ! 434: } ! 435: ! 436: // Build the list of bank rects & offsets for 2RW case ! 437: lScansPerBank = ! 438: BANK_SIZE_2RW_WINDOW / BankInfo->BitmapWidthInBytes; ! 439: lScan = -lScansBetweenBanks; // precompensate for 1st time ! 440: ulOffset = 0; ! 441: i = 0; ! 442: pbiWorking = pdsurf->pbiBankInfo2RW; ! 443: ! 444: do { ! 445: ! 446: lScan += lScansBetweenBanks; ! 447: pbiWorking->rclBankBounds.left = 0; ! 448: pbiWorking->rclBankBounds.right = pdsurf->sizlSurf.cx; ! 449: pbiWorking->rclBankBounds.top = lScan; ! 450: pbiWorking->rclBankBounds.bottom = lScan + lScansPerBank; ! 451: pbiWorking->ulBankOffset = ulOffset; ! 452: ulOffset += BankInfo->Granularity; ! 453: i++; ! 454: pbiWorking++; ! 455: ! 456: } while ((lScan + lScansPerBank) < lTotalScans); ! 457: ! 458: pdsurf->ulBankInfo2RWLength = i; ! 459: ! 460: } else { ! 461: ! 462: // Not a 2RW bank adapter, just use standard table for 2-window ! 463: // cases ! 464: ! 465: pdsurf->pbiBankInfo2RW = pdsurf->pbiBankInfo; ! 466: pdsurf->ulBankInfo2RWLength = pdsurf->ulBankInfoLength; ! 467: ! 468: } ! 469: ! 470: // Map in scan line 0 for read & write, to put things in a known state ! 471: ! 472: pdsurf->pfnBankControl(pdsurf, 0, JustifyTop); ! 473: ! 474: // Scan line to be used with JustifyBottom to map in the bank ! 475: // containing the pointer work and save areas, which are guaranteed not ! 476: // to span banks ! 477: pdsurf->ulPtrBankScan = (pdsurf->ulBitmapSize/pdsurf->lNextScan) - 1; ! 478: ! 479: } ! 480: ! 481: ! 482: return TRUE; ! 483: } ! 484: ! 485: /******************************Private*Routine******************************\ ! 486: * BankErrorTrap ! 487: * ! 488: * Traps calls to bank control functions in non-banked modes ! 489: * ! 490: \**************************************************************************/ ! 491: ! 492: void BankErrorTrap(PDEVSURF pdsurf, LONG lScan, ! 493: BANK_JUST ulJustification) ! 494: { ! 495: DISPDBG((0, "VGA.DLL: Call to bank manager in unbanked mode\n")); ! 496: } ! 497: ! 498: ! 499: /******************************Private*Routine******************************\ ! 500: * Bank1Window ! 501: * ! 502: * Maps in a single R/W window that allows access to lScan. Applies to both ! 503: * 1 RW window and 1R1W window banking schemes. ! 504: * ! 505: * Note: in the 1 R/W adapter case, this may be called with a fourth parameter ! 506: * (the source/dest selector), which is ignored. This is so that we can use the ! 507: * same routine as the destination for 1 R/W 2-window calls; those calls don't ! 508: * map in separate banks, of course, but they let us get away with common code ! 509: * for 1 R/W and 1R/1W in some cases (such as aligned blits). ! 510: * ! 511: \**************************************************************************/ ! 512: ! 513: void Bank1Window(PDEVSURF pdsurf, LONG lScan, ! 514: BANK_JUST ulJustification) ! 515: { ! 516: ULONG ulBank; ! 517: PBANK_INFO pbiWorking; ! 518: volatile ULONG ulBank0; ! 519: volatile PFN pBankFn; ! 520: ! 521: // ASM routines that call this may have STD in effect, but the C compiler ! 522: // assumes CLD ! 523: ! 524: _asm pushfd ! 525: _asm cld ! 526: ! 527: // Find the bank containing the scan line with the desired justification ! 528: if (ulJustification == JustifyTop) { ! 529: ! 530: // Map scan line in as near as possible to the top of the window ! 531: ulBank = pdsurf->ulBankInfoLength-1; ! 532: pbiWorking = pdsurf->pbiBankInfo + ulBank; ! 533: while (pbiWorking->rclBankBounds.top > lScan) { ! 534: ulBank--; ! 535: pbiWorking--; ! 536: } ! 537: ! 538: } else { ! 539: ! 540: // Map scan line in as near as possible to the bottom of the window ! 541: ulBank = 0; ! 542: pbiWorking = pdsurf->pbiBankInfo; ! 543: while (pbiWorking->rclBankBounds.bottom <= lScan) { ! 544: ulBank++; ! 545: pbiWorking++; ! 546: } ! 547: ! 548: } ! 549: ! 550: // Set the clip rect for this bank; if it's set to -1, that indicates that ! 551: // a double-window set-up is currently active, so invalidate double-window ! 552: // clip rects and display memory pointers (when double-window is active, ! 553: // single-window is inactive, and vice-versa; a full bank set-up has to be ! 554: // performed to switch between the two) ! 555: ! 556: if (pdsurf->rcl1WindowClip.top == -1) { ! 557: ! 558: pdsurf->rcl2WindowClip[0].top = ! 559: pdsurf->rcl2WindowClip[0].bottom = ! 560: pdsurf->rcl2WindowClip[0].right = ! 561: pdsurf->rcl2WindowClip[0].left = ! 562: pdsurf->rcl2WindowClip[1].top = ! 563: pdsurf->rcl2WindowClip[1].bottom = ! 564: pdsurf->rcl2WindowClip[1].right = ! 565: pdsurf->rcl2WindowClip[1].left = -1; ! 566: pdsurf->pvBitmapStart2Window[0] = (PDEVSURF) 0; ! 567: pdsurf->pvBitmapStart2Window[1] = (PDEVSURF) 0; ! 568: ! 569: } else { ! 570: // ASSERT(pdsurf->rcl2WindowClip[0].top == -1, ! 571: // "BANK.C: 2 bank src not mapped out"); ! 572: // ASSERT(pdsurf->rcl2WindowClip[1].top == -1, ! 573: // "BANK.C: 2 bank src not mapped out"); ! 574: } ! 575: ! 576: ! 577: pdsurf->rcl1WindowClip = pbiWorking->rclBankBounds; ! 578: ! 579: // Shift the bitmap start address so that the desired bank aligns with ! 580: // the banking window. The source and destination are set only so 1 R/W ! 581: // aligned blits will work without having to be specifically aware of ! 582: // the adapter type (some of the same code works with 1R/1W adapters too). ! 583: ! 584: pdsurf->pvBitmapStart = ! 585: pdsurf->pvBitmapStart2Window[0] = ! 586: pdsurf->pvBitmapStart2Window[1] = ! 587: (PVOID) ((UCHAR *)pdsurf->pvStart - pbiWorking->ulBankOffset); ! 588: ! 589: // Map in the desired bank for both read and write ! 590: // This is so convoluted to avoid problems with wiping out registers C ! 591: // thinks it's still using; the values are tranferred to volatiles, and ! 592: // then to registers ! 593: ! 594: ulBank0 = ulBank; ! 595: pBankFn = pdsurf->pfnBankSwitchCode; ! 596: _asm mov eax,ulBank0; ! 597: _asm mov edx,eax; ! 598: pBankFn(); // actually switch the banks ! 599: ! 600: _asm popfd ! 601: } ! 602: ! 603: ! 604: /******************************Private*Routine******************************\ ! 605: * Bank1Window2RW ! 606: * ! 607: * Maps in two 32K RW windows so that they form a single 64K R/W window that ! 608: * allows access to lScan. Applies only to 2 RW window schemes. ! 609: * ! 610: \**************************************************************************/ ! 611: ! 612: void Bank1Window2RW(PDEVSURF pdsurf, LONG lScan, ! 613: BANK_JUST ulJustification) ! 614: { ! 615: ULONG ulBank; ! 616: PBANK_INFO pbiWorking; ! 617: volatile ULONG ulBank0; ! 618: volatile ULONG ulBank1; ! 619: volatile PFN pBankFn; ! 620: ! 621: // ASM routines that call this may have STD in effect, but the C compiler ! 622: // assumes CLD ! 623: ! 624: _asm pushfd ! 625: _asm cld ! 626: ! 627: // Find the bank containing the scan line with the desired justification ! 628: if (ulJustification == JustifyTop) { ! 629: ! 630: // Map scan line in as near as possible to the top of the window ! 631: ulBank = pdsurf->ulBankInfoLength-1; ! 632: pbiWorking = pdsurf->pbiBankInfo + ulBank; ! 633: while (pbiWorking->rclBankBounds.top > lScan) { ! 634: ulBank--; ! 635: pbiWorking--; ! 636: } ! 637: ! 638: } else { ! 639: ! 640: // Map scan line in as near as possible to the bottom of the window ! 641: ulBank = 0; ! 642: pbiWorking = pdsurf->pbiBankInfo; ! 643: while (pbiWorking->rclBankBounds.bottom <= lScan) { ! 644: ulBank++; ! 645: pbiWorking++; ! 646: } ! 647: ! 648: } ! 649: ! 650: // Set the clip rect for this bank; if it's set to -1, that indicates that ! 651: // a double-window set-up is currently active, so invalidate double-window ! 652: // clip rects and display memory pointers (when double-window is active, ! 653: // single-window is inactive, and vice-versa; a full bank set-up has to be ! 654: // performed to switch between the two) ! 655: ! 656: if (pdsurf->rcl1WindowClip.top == -1) { ! 657: ! 658: pdsurf->rcl2WindowClip[0].top = ! 659: pdsurf->rcl2WindowClip[0].bottom = ! 660: pdsurf->rcl2WindowClip[0].right = ! 661: pdsurf->rcl2WindowClip[0].left = ! 662: pdsurf->rcl2WindowClip[1].top = ! 663: pdsurf->rcl2WindowClip[1].bottom = ! 664: pdsurf->rcl2WindowClip[1].right = ! 665: pdsurf->rcl2WindowClip[1].left = -1; ! 666: pdsurf->pvBitmapStart2Window[0] = (PDEVSURF) 0; ! 667: pdsurf->pvBitmapStart2Window[1] = (PDEVSURF) 0; ! 668: ! 669: } else { ! 670: // ASSERT(pdsurf->rcl2WindowClip[0].top == -1, ! 671: // "BANK.C: 2 bank src not mapped out"); ! 672: // ASSERT(pdsurf->rcl2WindowClip[1].top == -1, ! 673: // "BANK.C: 2 bank src not mapped out"); ! 674: } ! 675: ! 676: ! 677: pdsurf->rcl1WindowClip = pbiWorking->rclBankBounds; ! 678: ! 679: // Shift the bitmap start address so that the desired bank aligns with ! 680: // the banking window. The source and destination are set only so 1 R/W ! 681: // aligned blits will work without having to be specifically aware of ! 682: // the adapter type (some of the same code works with 1R/1W adapters too). ! 683: ! 684: pdsurf->pvBitmapStart = ! 685: pdsurf->pvBitmapStart2Window[0] = ! 686: pdsurf->pvBitmapStart2Window[1] = ! 687: (PVOID) ((UCHAR *)pdsurf->pvStart - pbiWorking->ulBankOffset); ! 688: ! 689: // Map in the desired bank for both read and write; this is accomplished ! 690: // by mapping in the desired 32K bank, followed by the next 32K bank. ! 691: // This is so convoluted to avoid problems with wiping out registers C ! 692: // thinks it's still using; the values are tranferred to volatiles, and ! 693: // then to registers ! 694: ! 695: ulBank0 = ulBank; ! 696: ulBank1 = ulBank0 + pdsurf->ulBank2RWSkip; ! 697: pBankFn = pdsurf->pfnBankSwitchCode; ! 698: _asm mov eax,ulBank0; ! 699: _asm mov edx,ulBank1; ! 700: pBankFn(); // actually switch the banks ! 701: ! 702: _asm popfd ! 703: } ! 704: ! 705: ! 706: /******************************Private*Routine******************************\ ! 707: * Bank2Window ! 708: * ! 709: * Maps in one of two windows, either the source window (window 0) or the dest ! 710: * window (window 1), to allows access to lScan. Applies to 1R1W window ! 711: * banking scheme; should never be called for 1 RW window schemes, because ! 712: * there's only one window in that case. ! 713: * ! 714: \**************************************************************************/ ! 715: ! 716: void Bank2Window(PDEVSURF pdsurf, LONG lScan, ! 717: BANK_JUST ulJustification, ULONG ulWindowToMap) ! 718: { ! 719: ULONG ulBank; ! 720: PBANK_INFO pbiWorking; ! 721: volatile ULONG ulBank0, ulBank1; ! 722: volatile PFN pBankFn; ! 723: ! 724: // ASM routines that call this may have STD in effect, but the C compiler ! 725: // assumes CLD ! 726: ! 727: _asm pushfd ! 728: _asm cld ! 729: ! 730: // Find the bank containing the scan line with the desired justification ! 731: if (ulJustification == JustifyTop) { ! 732: ! 733: // Map scan line in as near as possible to the top of the window ! 734: ulBank = pdsurf->ulBankInfoLength-1; ! 735: pbiWorking = pdsurf->pbiBankInfo + ulBank; ! 736: while (pbiWorking->rclBankBounds.top > lScan) { ! 737: ulBank--; ! 738: pbiWorking--; ! 739: } ! 740: ! 741: } else { ! 742: ! 743: // Map scan line in as near as possible to the bottom of the window ! 744: ulBank = 0; ! 745: pbiWorking = pdsurf->pbiBankInfo; ! 746: while (pbiWorking->rclBankBounds.bottom <= lScan) { ! 747: ulBank++; ! 748: pbiWorking++; ! 749: } ! 750: ! 751: } ! 752: ! 753: // Set the clip rect for this bank; if it's set to -1, that indicates that ! 754: // a single-window set-up is currently active, so invalidate single-window ! 755: // clip rects and display memory pointers (when double-window is active, ! 756: // single-window is inactive, and vice-versa; a full bank set-up has to be ! 757: // performed to switch between the two) ! 758: ! 759: if (pdsurf->rcl2WindowClip[ulWindowToMap].top == -1) { ! 760: ! 761: pdsurf->rcl1WindowClip.top = ! 762: pdsurf->rcl1WindowClip.bottom = ! 763: pdsurf->rcl1WindowClip.right = ! 764: pdsurf->rcl1WindowClip.left = -1; ! 765: pdsurf->pvBitmapStart = (PDEVSURF) 0; ! 766: ! 767: // Neither of the 2 window windows was active, so we have to set up the ! 768: // variables for the other bank (the one other than the one we were ! 769: // called to set) as well, to make it valid. The other bank is set to ! 770: // the same state as the bank we were called to set ! 771: pdsurf->rcl2WindowClip[ulWindowToMap^1] = pbiWorking->rclBankBounds; ! 772: pdsurf->pvBitmapStart2Window[ulWindowToMap^1] = ! 773: (PVOID) ((UCHAR *)pdsurf->pvStart - pbiWorking->ulBankOffset); ! 774: pdsurf->ulWindowBank[ulWindowToMap^1] = ulBank; ! 775: } else { ! 776: // ASSERT(pdsurf->rcl1WindowClip.top == -1, ! 777: // "BANK.C: 1 bank not mapped out"); ! 778: } ! 779: ! 780: pdsurf->rcl2WindowClip[ulWindowToMap] = pbiWorking->rclBankBounds; ! 781: ! 782: // Shift the bitmap start address so that the desired bank aligns with the ! 783: // banking window ! 784: ! 785: pdsurf->pvBitmapStart2Window[ulWindowToMap] = ! 786: (PVOID) ((UCHAR *)pdsurf->pvStart - pbiWorking->ulBankOffset); ! 787: ! 788: // Map in the desired bank; also map in the other bank to whatever its ! 789: // current state is ! 790: ! 791: pdsurf->ulWindowBank[ulWindowToMap] = ulBank; ! 792: ! 793: // Set both banks at once, because we may have just initialized the other ! 794: // bank, and because this way the bank switch code doesn't have to do a ! 795: // read before write to obtain the state of the other bank. ! 796: // This is so convoluted to avoid problems with wiping out registers C ! 797: // thinks it's still using; the values are tranferred to volatiles, and ! 798: // then to registers ! 799: ! 800: ulBank0 = pdsurf->ulWindowBank[0]; ! 801: ulBank1 = pdsurf->ulWindowBank[1]; ! 802: pBankFn = pdsurf->pfnBankSwitchCode; ! 803: _asm mov eax,ulBank0; ! 804: _asm mov edx,ulBank1; ! 805: pBankFn(); // actually switch the banks ! 806: ! 807: _asm popfd ! 808: } ! 809: ! 810: ! 811: /******************************Private*Routine******************************\ ! 812: * Bank2Window1RW ! 813: * ! 814: * Maps in the one window in 1R/W case. Does exactly the same thing as the ! 815: * one window case, because there's only one window, but has to be a separate ! 816: * entry point because of the extra parameter (because we're using STDCALL). ! 817: \**************************************************************************/ ! 818: ! 819: void Bank2Window1RW(PDEVSURF pdsurf, LONG lScan, ! 820: BANK_JUST ulJustification, ULONG ulWindowToMap) ! 821: { ! 822: Bank1Window(pdsurf, lScan, ulJustification); ! 823: } ! 824: ! 825: ! 826: /******************************Private*Routine******************************\ ! 827: * Bank2Window2RW ! 828: * ! 829: * Maps in one of two windows, either the source window (window 0) or the dest ! 830: * window (window 1), to allows access to lScan. Applies to 2RW window ! 831: * banking scheme; should never be called for 1 RW window schemes, because ! 832: * there's only one window in that case. ! 833: \**************************************************************************/ ! 834: ! 835: void Bank2Window2RW(PDEVSURF pdsurf, LONG lScan, ! 836: BANK_JUST ulJustification, ULONG ulWindowToMap) ! 837: { ! 838: ULONG ulBank; ! 839: PBANK_INFO pbiWorking; ! 840: volatile ULONG ulBank0, ulBank1; ! 841: volatile PFN pBankFn; ! 842: ! 843: // ASM routines that call this may have STD in effect, but the C compiler ! 844: // assumes CLD ! 845: ! 846: _asm pushfd ! 847: _asm cld ! 848: ! 849: // Find the bank containing the scan line with the desired justification ! 850: if (ulJustification == JustifyTop) { ! 851: ! 852: // Map scan line in as near as possible to the top of the window ! 853: ulBank = pdsurf->ulBankInfo2RWLength-1; ! 854: pbiWorking = pdsurf->pbiBankInfo2RW + ulBank; ! 855: while (pbiWorking->rclBankBounds.top > lScan) { ! 856: ulBank--; ! 857: pbiWorking--; ! 858: } ! 859: ! 860: } else { ! 861: ! 862: // Map scan line in as near as possible to the bottom of the window ! 863: ulBank = 0; ! 864: pbiWorking = pdsurf->pbiBankInfo2RW; ! 865: while (pbiWorking->rclBankBounds.bottom <= lScan) { ! 866: ulBank++; ! 867: pbiWorking++; ! 868: } ! 869: ! 870: } ! 871: ! 872: // Set the clip rect for this bank; if it's set to -1, that indicates that ! 873: // a single-window set-up is currently active, so invalidate single-window ! 874: // clip rects and display memory pointers (when double-window is active, ! 875: // single-window is inactive, and vice-versa; a full bank set-up has to be ! 876: // performed to switch between the two) ! 877: ! 878: if (pdsurf->rcl2WindowClip[ulWindowToMap].top == -1) { ! 879: ! 880: pdsurf->rcl1WindowClip.top = ! 881: pdsurf->rcl1WindowClip.bottom = ! 882: pdsurf->rcl1WindowClip.right = ! 883: pdsurf->rcl1WindowClip.left = -1; ! 884: pdsurf->pvBitmapStart = (PDEVSURF) 0; ! 885: ! 886: // Neither of the 2 window windows was active, so we have to set up the ! 887: // variables for the other bank (the one other than the one we were ! 888: // called to set) as well, to make it valid. The other bank is set to ! 889: // the same state as the bank we were called to set ! 890: pdsurf->rcl2WindowClip[ulWindowToMap^1] = pbiWorking->rclBankBounds; ! 891: if (ulWindowToMap == 1) { ! 892: pdsurf->pvBitmapStart2Window[0] = ! 893: (PVOID) ((UCHAR *)pdsurf->pvStart - pbiWorking->ulBankOffset); ! 894: } else { ! 895: pdsurf->pvBitmapStart2Window[1] = ! 896: (PVOID) ((UCHAR *)pdsurf->pvStart - pbiWorking->ulBankOffset + ! 897: BANK_SIZE_2RW_WINDOW); ! 898: } ! 899: pdsurf->ulWindowBank[ulWindowToMap^1] = ulBank; ! 900: } else { ! 901: // ASSERT(pdsurf->rcl1WindowClip.top == -1, ! 902: // "BANK.C: 1 bank not mapped out"); ! 903: } ! 904: ! 905: pdsurf->rcl2WindowClip[ulWindowToMap] = pbiWorking->rclBankBounds; ! 906: ! 907: // Shift the bitmap start address so that the desired bank aligns with the ! 908: // banking window ! 909: ! 910: if (ulWindowToMap == 0) { ! 911: pdsurf->pvBitmapStart2Window[0] = ! 912: (PVOID) ((UCHAR *)pdsurf->pvStart - pbiWorking->ulBankOffset); ! 913: } else { ! 914: pdsurf->pvBitmapStart2Window[1] = ! 915: (PVOID) ((UCHAR *)pdsurf->pvStart - pbiWorking->ulBankOffset + ! 916: BANK_SIZE_2RW_WINDOW); ! 917: } ! 918: ! 919: // Map in the desired bank; also map in the other bank to whatever its ! 920: // current state is ! 921: ! 922: pdsurf->ulWindowBank[ulWindowToMap] = ulBank; ! 923: ! 924: // Set both banks at once, because we may have just initialized the other ! 925: // bank, and because this way the bank switch code doesn't have to do a ! 926: // read before write to obtain the state of the other bank. ! 927: // This is so convoluted to avoid problems with wiping out registers C ! 928: // thinks it's still using; the values are tranferred to volatiles, and ! 929: // then to registers ! 930: ! 931: ulBank0 = pdsurf->ulWindowBank[0]; ! 932: ulBank1 = pdsurf->ulWindowBank[1]; ! 933: pBankFn = pdsurf->pfnBankSwitchCode; ! 934: _asm mov eax,ulBank0; ! 935: _asm mov edx,ulBank1; ! 936: pBankFn(); // actually switch the banks ! 937: ! 938: _asm popfd ! 939: } ! 940: ! 941: ! 942: /************************************************************************\ ! 943: * DrvIntersectRect ! 944: * ! 945: * Calculates the intersection between *prcSrc1 and *prcSrc2, ! 946: * returning the resulting rect in *prcDst. Returns TRUE if ! 947: * *prcSrc1 intersects *prcSrc2, FALSE otherwise. If there is no ! 948: * intersection, an empty rect is returned in *prcDst ! 949: \************************************************************************/ ! 950: static const RECTL rclEmpty = { 0, 0, 0, 0 }; ! 951: ! 952: BOOL DrvIntersectRect( ! 953: PRECTL prcDst, ! 954: PRECTL prcSrc1, ! 955: PRECTL prcSrc2) ! 956: ! 957: { ! 958: prcDst->left = max(prcSrc1->left, prcSrc2->left); ! 959: prcDst->right = min(prcSrc1->right, prcSrc2->right); ! 960: ! 961: /* ! 962: * check for empty rect ! 963: */ ! 964: if (prcDst->left < prcDst->right) { ! 965: ! 966: prcDst->top = max(prcSrc1->top, prcSrc2->top); ! 967: prcDst->bottom = min(prcSrc1->bottom, prcSrc2->bottom); ! 968: ! 969: /* ! 970: * check for empty rect ! 971: */ ! 972: if (prcDst->top < prcDst->bottom) { ! 973: return TRUE; // not empty ! 974: } ! 975: } ! 976: ! 977: /* ! 978: * empty rect ! 979: */ ! 980: *prcDst = rclEmpty; ! 981: ! 982: return FALSE; ! 983: } ! 984: ! 985: /************************************************************************\ ! 986: * vForceBank0 ! 987: * ! 988: * Forces the VGA to map in bank 0 if there's banking. Intended for use ! 989: * when returning from fullscreen, so a known bank is mapped. ! 990: \************************************************************************/ ! 991: VOID vForceBank0( ! 992: PPDEV ppdev) ! 993: { ! 994: PDEVSURF pdsurf = ppdev->pdsurf; ! 995: ! 996: if (pdsurf->vbtBankingType != VideoNotBanked) { ! 997: ! 998: // Set all clip rects to invalid; they'll be updated when we map in ! 999: // bank 0 ! 1000: pdsurf->rcl1WindowClip.left = pdsurf->rcl2WindowClip[0].left = ! 1001: pdsurf->rcl2WindowClip[1].left = pdsurf->rcl1WindowClip.top = ! 1002: pdsurf->rcl2WindowClip[0].top = pdsurf->rcl2WindowClip[1].top = ! 1003: pdsurf->rcl1WindowClip.right = pdsurf->rcl2WindowClip[0].right = ! 1004: pdsurf->rcl2WindowClip[1].right = pdsurf->rcl1WindowClip.bottom = ! 1005: pdsurf->rcl2WindowClip[0].bottom = ! 1006: pdsurf->rcl2WindowClip[1].bottom = -1; ! 1007: ! 1008: // Map in scan line 0 for read & write, to put things in a known state ! 1009: pdsurf->pfnBankControl(pdsurf, 0, JustifyTop); ! 1010: } ! 1011: } ! 1012:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.