![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pointer.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 / s3|
Return to pointer.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / s3 |
1.1 ! root 1: /******************************Module*Header*******************************\ ! 2: * Module Name: pointer.c ! 3: * ! 4: * This module contains the hardware cursor support for Disp. ! 5: * ! 6: * Copyright (c) 1992 Microsoft Corporation ! 7: \**************************************************************************/ ! 8: ! 9: #include "driver.h" ! 10: ! 11: ! 12: ULONG DrvSetColorPointerShape( ! 13: SURFOBJ *pso, ! 14: SURFOBJ *psoMask, ! 15: SURFOBJ *psoColor, ! 16: XLATEOBJ *pxlo, ! 17: LONG xHot, ! 18: LONG yHot, ! 19: LONG x, ! 20: LONG y, ! 21: RECTL *prcl, ! 22: FLONG fl ! 23: ); ! 24: ! 25: ULONG DrvSetMonoHwPointerShape( ! 26: SURFOBJ *pso, ! 27: SURFOBJ *psoMask, ! 28: SURFOBJ *psoColor, ! 29: XLATEOBJ *pxlo, ! 30: LONG xHot, ! 31: LONG yHot, ! 32: LONG x, ! 33: LONG y, ! 34: RECTL *prcl, ! 35: FLONG fl ! 36: ); ! 37: ! 38: ULONG DrvSetBt485PointerShape( ! 39: SURFOBJ *pso, ! 40: SURFOBJ *psoMask, ! 41: SURFOBJ *psoColor, ! 42: XLATEOBJ *pxlo, ! 43: LONG xHot, ! 44: LONG yHot, ! 45: LONG x, ! 46: LONG y, ! 47: RECTL *prcl, ! 48: FLONG fl ! 49: ); ! 50: ! 51: ! 52: ! 53: VOID DrvMoveColorPointer(SURFOBJ *pso,LONG x,LONG y,RECTL *prcl); ! 54: VOID DrvMoveHwPointer(SURFOBJ *pso,LONG x,LONG y,RECTL *prcl); ! 55: VOID DrvMoveBt485Pointer(SURFOBJ *pso, LONG x, LONG y, RECTL *prcl); ! 56: ! 57: ! 58: ! 59: /***************************************************************************** ! 60: * DrvMovePointer - ! 61: ****************************************************************************/ ! 62: VOID DrvMovePointer( ! 63: SURFOBJ *pso, ! 64: LONG x, ! 65: LONG y, ! 66: RECTL *prcl) ! 67: { ! 68: PPDEV ppdev; ! 69: ! 70: ppdev = (PPDEV) pso->dhpdev; ! 71: ! 72: if (ppdev->flPointer & COLOR_POINTER) ! 73: DrvMoveColorPointer(pso, x, y, prcl); ! 74: else ! 75: { ! 76: if (ppdev->bBt485Dac == TRUE) ! 77: { ! 78: DrvMoveBt485Pointer(pso, x, y, prcl); ! 79: } ! 80: else ! 81: { ! 82: DrvMoveHwPointer(pso, x, y, prcl); ! 83: } ! 84: } ! 85: } ! 86: ! 87: ! 88: /***************************************************************************** ! 89: * DrvMoveColorPointer - ! 90: ****************************************************************************/ ! 91: VOID DrvMoveColorPointer( ! 92: SURFOBJ *pso, ! 93: LONG x, ! 94: LONG y, ! 95: RECTL *prcl) ! 96: { ! 97: INT xDest, yDest; ! 98: WORD cmd; ! 99: RECTL rclClip; ! 100: PPDEV ppdev; ! 101: ! 102: ppdev = (PPDEV) pso->dhpdev; ! 103: ! 104: // Sync with the rest of the driver. ! 105: ! 106: GPWAIT(); ! 107: ! 108: // If x is -1 then take down the cursor. ! 109: ! 110: if (x == -1) ! 111: { ! 112: ppdev->flPointer |= TAKE_DOWN_POINTER; ! 113: } ! 114: ! 115: // Adjust the actual position on the screen for the hot spot. ! 116: ! 117: xDest = x - ppdev->ptlHotSpot.x; ! 118: yDest = y - ppdev->ptlHotSpot.y; ! 119: ! 120: // If the save buffer has valid data, copy whats in the save ! 121: // buffer back to the screen. ! 122: ! 123: if (((ppdev->flPointer & VALID_SAVE_BUFFER) && ! 124: (!(ppdev->flPointer & ANIMATEUPDATE))) || ! 125: ((ppdev->flPointer & VALID_SAVE_BUFFER) && ! 126: (ppdev->flPointer & ANIMATEUPDATE) && ! 127: ((ppdev->ptlLastPosition.x != xDest) || ! 128: (ppdev->ptlLastPosition.y != yDest)))) ! 129: { ! 130: // The restore will always take place to the screen, ! 131: // so limit the clip area to the screen. ! 132: ! 133: rclClip.left = 0; ! 134: rclClip.top = 0; ! 135: rclClip.right = ppdev->cxScreen; ! 136: rclClip.bottom = ppdev->cyScreen; ! 137: ! 138: vSetS3ClipRect(ppdev, &rclClip); ! 139: ! 140: cmd = BITBLT | DRAW | DIR_TYPE_XY | ! 141: DRAWING_DIR_TBLRXM | WRITE; ! 142: ! 143: FIFOWAIT(FIFO_2_EMPTY); ! 144: ! 145: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | OVERPAINT); ! 146: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 147: ! 148: FIFOWAIT(FIFO_7_EMPTY); ! 149: ! 150: OUTPW(RECT_WIDTH, ppdev->szlPointer.cx - 1); ! 151: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | ppdev->szlPointer.cy - 1)); ! 152: OUTPW(CUR_X, COLOR_POINTER_SAVE_X); ! 153: OUTPW(CUR_Y, COLOR_POINTER_Y); ! 154: OUTPW(DEST_X, ppdev->ptlLastPosition.x); ! 155: OUTPW(DEST_Y, ppdev->ptlLastPosition.y); ! 156: ! 157: OUTPW(CMD, cmd); ! 158: ! 159: // Indicate that the save buffer is no longer valid. ! 160: ! 161: ppdev->flPointer &= ~VALID_SAVE_BUFFER; ! 162: ! 163: } ! 164: ! 165: // If we're just taking down the pointer then were done, ! 166: // so this an early exit. ! 167: ! 168: if (ppdev->flPointer & TAKE_DOWN_POINTER ) ! 169: { ! 170: ppdev->flPointer &= ~TAKE_DOWN_POINTER; ! 171: vResetS3Clipping(ppdev); ! 172: return; ! 173: } ! 174: ! 175: ! 176: // Set the clipping for the pointers masks, save, and work area. ! 177: ! 178: rclClip.left = 0; ! 179: rclClip.top = COLOR_POINTER_Y; ! 180: rclClip.right = COLOR_POINTER_SAVE_X + COLOR_POINTER_CX; ! 181: rclClip.bottom = (COLOR_POINTER_Y + COLOR_POINTER_CY); ! 182: ! 183: vSetS3ClipRect(ppdev, &rclClip); ! 184: ! 185: if (!(ppdev->flPointer & ANIMATEUPDATE) || ! 186: !(ppdev->flPointer & VALID_SAVE_BUFFER)) ! 187: { ! 188: // Save the area under where we plan to draw the new cursor. ! 189: ! 190: cmd = BITBLT | DRAW | DIR_TYPE_XY | ! 191: DRAWING_DIR_TBLRXM | WRITE; ! 192: ! 193: FIFOWAIT(FIFO_2_EMPTY); ! 194: ! 195: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | OVERPAINT); ! 196: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 197: ! 198: FIFOWAIT(FIFO_7_EMPTY); ! 199: ! 200: OUTPW(RECT_WIDTH, ppdev->szlPointer.cx - 1); ! 201: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | ppdev->szlPointer.cy - 1)); ! 202: OUTPW(CUR_X, xDest); ! 203: OUTPW(CUR_Y, yDest); ! 204: OUTPW(DEST_X,COLOR_POINTER_SAVE_X); ! 205: OUTPW(DEST_Y,COLOR_POINTER_Y); ! 206: ! 207: OUTPW(CMD, cmd); ! 208: } ! 209: ! 210: // Validate the save buffer. ! 211: ! 212: ppdev->flPointer |= VALID_SAVE_BUFFER; ! 213: ! 214: // Now copy the saved data to the work buffer. ! 215: ! 216: cmd = BITBLT | DRAW | DIR_TYPE_XY | ! 217: DRAWING_DIR_TBLRXM | WRITE; ! 218: ! 219: FIFOWAIT(FIFO_2_EMPTY); ! 220: ! 221: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | OVERPAINT); ! 222: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 223: ! 224: FIFOWAIT(FIFO_7_EMPTY); ! 225: ! 226: OUTPW(RECT_WIDTH, ppdev->szlPointer.cx - 1); ! 227: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | ppdev->szlPointer.cy - 1)); ! 228: OUTPW(CUR_X, COLOR_POINTER_SAVE_X); ! 229: OUTPW(CUR_Y, COLOR_POINTER_Y); ! 230: OUTPW(DEST_X,COLOR_POINTER_WORK_X); ! 231: OUTPW(DEST_Y,COLOR_POINTER_Y); ! 232: ! 233: OUTPW(CMD, cmd); ! 234: ! 235: // Record the current position as the last position; ! 236: ! 237: ppdev->ptlLastPosition.x = xDest; ! 238: ppdev->ptlLastPosition.y = yDest; ! 239: ! 240: // AND in the AND mask to the work buffer ! 241: ! 242: cmd = BITBLT | DRAW | DIR_TYPE_XY | ! 243: DRAWING_DIR_TBLRXM | MULTIPLE_PIXELS | WRITE; ! 244: ! 245: FIFOWAIT(FIFO_6_EMPTY); ! 246: ! 247: TEST_AND_SET_FRGD_MIX(FOREGROUND_COLOR | SCREEN_AND_NEW); ! 248: TEST_AND_SET_FRGD_COLOR(0xff); ! 249: TEST_AND_SET_BKGD_MIX(BACKGROUND_COLOR | SCREEN_AND_NEW); ! 250: SET_BKGD_COLOR(0x00); ! 251: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | DISPLAY_MEMORY)); ! 252: TEST_AND_SET_RD_MASK(COLOR_POINTER_AND_PLANE); ! 253: ! 254: ! 255: FIFOWAIT(FIFO_7_EMPTY); ! 256: ! 257: OUTPW(RECT_WIDTH, ppdev->szlPointer.cx - 1); ! 258: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | ppdev->szlPointer.cy - 1)); ! 259: OUTPW(CUR_X, 0); ! 260: OUTPW(CUR_Y, COLOR_POINTER_Y); ! 261: OUTPW(DEST_X,COLOR_POINTER_WORK_X); ! 262: OUTPW(DEST_Y,COLOR_POINTER_Y); ! 263: OUTPW(CMD, cmd); ! 264: ! 265: FIFOWAIT(FIFO_1_EMPTY); ! 266: ! 267: TEST_AND_SET_RD_MASK(0xff); ! 268: ! 269: // Or in the Color data to the work buffer. ! 270: ! 271: cmd = BITBLT | DRAW | DIR_TYPE_XY | ! 272: DRAWING_DIR_TBLRXM | SINGLE_PIXEL | WRITE; ! 273: ! 274: FIFOWAIT(FIFO_3_EMPTY); ! 275: ! 276: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | SCREEN_OR_NEW); ! 277: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 278: ! 279: FIFOWAIT(FIFO_7_EMPTY); ! 280: ! 281: OUTPW(RECT_WIDTH, ppdev->szlPointer.cx - 1); ! 282: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | ppdev->szlPointer.cy - 1)); ! 283: OUTPW(CUR_X, COLOR_POINTER_COLOR_DATA_X); ! 284: OUTPW(CUR_Y, COLOR_POINTER_Y); ! 285: OUTPW(DEST_X,COLOR_POINTER_WORK_X); ! 286: OUTPW(DEST_Y,COLOR_POINTER_Y); ! 287: OUTPW(CMD, cmd); ! 288: ! 289: // Now copy the work buffer to the screen. ! 290: ! 291: rclClip.left = 0; ! 292: rclClip.top = 0; ! 293: rclClip.right = ppdev->cxScreen; ! 294: rclClip.bottom = ppdev->cyScreen; ! 295: ! 296: vSetS3ClipRect(ppdev, &rclClip); ! 297: ! 298: cmd = BITBLT | DRAW | DIR_TYPE_XY | ! 299: DRAWING_DIR_TBLRXM | WRITE; ! 300: ! 301: FIFOWAIT(FIFO_2_EMPTY); ! 302: ! 303: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | OVERPAINT); ! 304: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 305: ! 306: FIFOWAIT(FIFO_7_EMPTY); ! 307: ! 308: OUTPW(RECT_WIDTH, ppdev->szlPointer.cx - 1); ! 309: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | ppdev->szlPointer.cy - 1)); ! 310: OUTPW(CUR_X, COLOR_POINTER_WORK_X); ! 311: OUTPW(CUR_Y, COLOR_POINTER_Y); ! 312: OUTPW(DEST_X, xDest); ! 313: OUTPW(DEST_Y, yDest); ! 314: OUTPW(CMD, cmd); ! 315: ! 316: FIFOWAIT(FIFO_1_EMPTY); ! 317: ! 318: TEST_AND_SET_RD_MASK(0xff); ! 319: ! 320: // If the GDI requests the bounding box of the pointer, ! 321: // return it. ! 322: ! 323: if (prcl != NULL) ! 324: { ! 325: prcl->left = xDest; ! 326: prcl->top = yDest; ! 327: prcl->right = xDest + ppdev->szlPointer.cx; ! 328: prcl->bottom = yDest + ppdev->szlPointer.cy; ! 329: ! 330: } ! 331: ! 332: // Reset the clipping. This can go when no H/W clipping is done ! 333: // on the color pointer. ! 334: ! 335: vResetS3Clipping(ppdev); ! 336: } ! 337: ! 338: /***************************************************************************** ! 339: * DrvMoveHwPointer - ! 340: ****************************************************************************/ ! 341: VOID DrvMoveHwPointer( ! 342: SURFOBJ *pso, ! 343: LONG x, ! 344: LONG y, ! 345: RECTL *prcl) ! 346: { ! 347: WORD msb, lsb; ! 348: ! 349: PPDEV ppdev; ! 350: ! 351: ppdev = (PPDEV) pso->dhpdev; ! 352: ! 353: // Save the CRTC Index. ! 354: ! 355: ppdev->CrtcIndex = INP(CRTC_INDEX); ! 356: ! 357: // If x is -1 then take down the cursor. ! 358: ! 359: if (x == -1) ! 360: { ! 361: OUTPW (CRTC_INDEX, (ppdev->HgcMode & ~(HGC_ENABLE << 8))); ! 362: } ! 363: ! 364: // Adjust the actual pointer position depending upon ! 365: // the hot spot. ! 366: ! 367: x -= ppdev->ptlHotSpot.x; ! 368: y -= ppdev->ptlHotSpot.y; ! 369: ! 370: // Record the current position as the last position; ! 371: ! 372: ppdev->ptlLastPosition.x = x; ! 373: ppdev->ptlLastPosition.y = y; ! 374: ! 375: if (x <= 0) ! 376: { ! 377: OUTPW (CRTC_INDEX, ((-x << 8) | HGC_DX)); ! 378: x = 0; ! 379: } ! 380: else ! 381: { ! 382: OUTPW (CRTC_INDEX, ((0 << 8) | HGC_DX)); ! 383: } ! 384: ! 385: if (y <= 0) ! 386: { ! 387: OUTPW (CRTC_INDEX, ((-y << 8) | HGC_DY)); ! 388: y = 0; ! 389: } ! 390: else ! 391: { ! 392: OUTPW (CRTC_INDEX, ((0 << 8) | HGC_DY)); ! 393: } ! 394: ! 395: // Set the position of the cursor. ! 396: ! 397: msb = HIBYTE (x); ! 398: lsb = LOBYTE (x); ! 399: OUTPW (CRTC_INDEX, ((lsb << 8) | HGC_ORGX_LSB)); ! 400: OUTPW (CRTC_INDEX, ((msb << 8) | HGC_ORGX_MSB)); ! 401: ! 402: msb = HIBYTE (y); ! 403: lsb = LOBYTE (y); ! 404: OUTPW (CRTC_INDEX, ((lsb << 8) | HGC_ORGY_LSB)); ! 405: OUTPW (CRTC_INDEX, ((msb << 8) | HGC_ORGY_MSB)); ! 406: ! 407: // Restore the CRTC index ! 408: ! 409: OUTP(CRTC_INDEX, ppdev->CrtcIndex); ! 410: ! 411: } ! 412: ! 413: /***************************************************************************** ! 414: * DrvMoveBt485Pointer - ! 415: ****************************************************************************/ ! 416: VOID DrvMoveBt485Pointer( ! 417: SURFOBJ *pso, ! 418: LONG x, ! 419: LONG y, ! 420: RECTL *prcl) ! 421: { ! 422: WORD msb, lsb; ! 423: ! 424: PPDEV ppdev; ! 425: ! 426: ppdev = (PPDEV) pso->dhpdev; ! 427: ! 428: // Save the CRTC Index. ! 429: ! 430: ppdev->CrtcIndex = INP(CRTC_INDEX); ! 431: ! 432: // If x is -1 then take down the cursor. ! 433: ! 434: if (x == -1) ! 435: { ! 436: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0200)); ! 437: OUTP (BT485_ADDR_CMD_REG2, ppdev->Bt485CmdReg2 & BT485_CURSOR_DISABLE); ! 438: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl)); ! 439: ! 440: return; ! 441: } ! 442: ! 443: // Adjust the actual pointer position depending upon ! 444: // the hot spot. ! 445: ! 446: x -= ppdev->ptlHotSpot.x; ! 447: y -= ppdev->ptlHotSpot.y; ! 448: ! 449: // Record the current position as the last position; ! 450: ! 451: ppdev->ptlLastPosition.x = x; ! 452: ppdev->ptlLastPosition.y = y; ! 453: ! 454: // Adjust for the placement in the Bt485 ! 455: ! 456: x += 64; ! 457: y += 64; ! 458: ! 459: // Set the position of the cursor. ! 460: ! 461: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0300)); ! 462: ! 463: msb = HIBYTE (x); ! 464: lsb = LOBYTE (x); ! 465: ! 466: OUTP(BT485_CURSOR_X_LOW, lsb); ! 467: OUTP(BT485_CURSOR_X_HIGH, msb); ! 468: ! 469: msb = HIBYTE (y); ! 470: lsb = LOBYTE (y); ! 471: ! 472: OUTP(BT485_CURSOR_Y_LOW, lsb); ! 473: OUTP(BT485_CURSOR_Y_HIGH, msb); ! 474: ! 475: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl)); ! 476: ! 477: // Restore the CRTC index ! 478: ! 479: OUTP(CRTC_INDEX, ppdev->CrtcIndex); ! 480: ! 481: } ! 482: ! 483: ! 484: ! 485: /***************************************************************************** ! 486: * DrvSetPointerShape - ! 487: ****************************************************************************/ ! 488: ULONG DrvSetPointerShape( ! 489: SURFOBJ *pso, ! 490: SURFOBJ *psoMask, ! 491: SURFOBJ *psoColor, ! 492: XLATEOBJ *pxlo, ! 493: LONG xHot, ! 494: LONG yHot, ! 495: LONG x, ! 496: LONG y, ! 497: RECTL *prcl, ! 498: FLONG fl) ! 499: { ! 500: ULONG ulRet; ! 501: PPDEV ppdev; ! 502: BOOL bResetAnimateFlag; ! 503: ! 504: ppdev = (PPDEV) pso->dhpdev; ! 505: ! 506: // Save the hot spot in the pdev. ! 507: ! 508: ppdev->ptlHotSpot.x = xHot; ! 509: ppdev->ptlHotSpot.y = yHot; ! 510: ! 511: ppdev->szlPointer.cx = psoMask->sizlBitmap.cx; ! 512: ppdev->szlPointer.cy = psoMask->sizlBitmap.cy / 2; ! 513: ! 514: // The pointer may be larger than we can handle. ! 515: // If it is we must cleanup the screen and let the engine ! 516: // take care of it. ! 517: ! 518: if (psoMask->sizlBitmap.cx > 64 || psoMask->sizlBitmap.cy > 64) ! 519: { ! 520: // If it's a color pointer take it down. ! 521: ! 522: if ( (ppdev->flPointer & COLOR_POINTER) ! 523: && (ppdev->flPointer & VALID_SAVE_BUFFER) ! 524: ) ! 525: { ! 526: ulRet = DrvSetColorPointerShape(pso, NULL, NULL, NULL, ! 527: 0, 0, 0, 0, NULL, 0); ! 528: } ! 529: ! 530: // Disable the mono hardware pointer. ! 531: ! 532: if (ppdev->bBt485Dac == TRUE) ! 533: { ! 534: // Disable the H/W cursor on the Bt 485. ! 535: ! 536: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0200)); ! 537: OUTP (BT485_ADDR_CMD_REG2, ppdev->Bt485CmdReg2 & BT485_CURSOR_DISABLE); ! 538: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl)); ! 539: ! 540: } ! 541: else ! 542: { ! 543: OUTPW (CRTC_INDEX, (ppdev->HgcMode & ~(HGC_ENABLE << 8))); ! 544: } ! 545: ! 546: // reset our local pointer flags. ! 547: ! 548: ppdev->flPointer = 0; ! 549: ! 550: return (SPS_DECLINE); ! 551: ! 552: } ! 553: ! 554: // Set the AnimateUpdate flag. ! 555: ! 556: if ((fl & SPS_ANIMATEUPDATE) && ! 557: ((x - xHot) == ppdev->ptlLastPosition.x) && ! 558: ((y - yHot) == ppdev->ptlLastPosition.y)) ! 559: { ! 560: ppdev->flPointer |= ANIMATEUPDATE; ! 561: } ! 562: else ! 563: { ! 564: ppdev->flPointer &= ~ANIMATEUPDATE; ! 565: } ! 566: ! 567: if (psoColor != NULL) ! 568: { ! 569: // Disable the mono hardware pointer. ! 570: ! 571: if (ppdev->bBt485Dac == TRUE) ! 572: { ! 573: // Disable the H/W cursor on the Bt 485. ! 574: ! 575: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0200)); ! 576: OUTP (BT485_ADDR_CMD_REG2, ppdev->Bt485CmdReg2 & BT485_CURSOR_DISABLE); ! 577: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl)); ! 578: ! 579: } ! 580: else ! 581: { ! 582: OUTPW (CRTC_INDEX, (ppdev->HgcMode & ~(HGC_ENABLE << 8))); ! 583: } ! 584: ! 585: ppdev->flPointer |= COLOR_POINTER; ! 586: ulRet = DrvSetColorPointerShape(pso, psoMask, psoColor, pxlo, ! 587: xHot, yHot, x, y, prcl, fl); ! 588: ! 589: } ! 590: else ! 591: { ! 592: // Take down the color pointer if it is visible. ! 593: ! 594: if ( (ppdev->flPointer & COLOR_POINTER) ! 595: && (ppdev->flPointer & VALID_SAVE_BUFFER) ! 596: ) ! 597: { ! 598: // If we are making a transition from a color to a monochrome pointer ! 599: // and we haven't moved the pointer, and we're still in Animate Update mode, ! 600: // then we have to turn off the Animate Update flag for this call to turn off ! 601: // the color pointer. ! 602: ! 603: if (ppdev->flPointer & ANIMATEUPDATE) ! 604: { ! 605: bResetAnimateFlag = TRUE; ! 606: ppdev->flPointer &= ~ANIMATEUPDATE; ! 607: } ! 608: else ! 609: { ! 610: bResetAnimateFlag = FALSE; ! 611: } ! 612: ! 613: ulRet = DrvSetColorPointerShape(pso, NULL, NULL, NULL, ! 614: 0, 0, 0, 0, NULL, 0); ! 615: ! 616: if (bResetAnimateFlag == TRUE) ! 617: { ! 618: ppdev->flPointer |= ANIMATEUPDATE; ! 619: } ! 620: } ! 621: ! 622: // Take care of the monochrome pointer. ! 623: ! 624: ppdev->flPointer &= ~COLOR_POINTER; ! 625: ! 626: if (ppdev->bBt485Dac == TRUE) ! 627: { ! 628: ulRet = DrvSetBt485PointerShape(pso, psoMask, psoColor, pxlo, ! 629: xHot, yHot, x, y, prcl, fl); ! 630: } ! 631: else ! 632: { ! 633: ulRet = DrvSetMonoHwPointerShape(pso, psoMask, psoColor, pxlo, ! 634: xHot, yHot, x, y, prcl, fl); ! 635: } ! 636: } ! 637: ! 638: // Now that we have done an animation update, revert to a normal ! 639: // pointer. ! 640: ! 641: if (ppdev->flPointer & ANIMATEUPDATE) ! 642: { ! 643: ppdev->flPointer &= ~ANIMATEUPDATE; ! 644: } ! 645: ! 646: return (ulRet); ! 647: } ! 648: ! 649: ! 650: /***************************************************************************** ! 651: * DrvSetColorPointerShape - ! 652: ****************************************************************************/ ! 653: ULONG DrvSetColorPointerShape( ! 654: SURFOBJ *pso, ! 655: SURFOBJ *psoMask, ! 656: SURFOBJ *psoColor, ! 657: XLATEOBJ *pxlo, ! 658: LONG xHot, ! 659: LONG yHot, ! 660: LONG x, ! 661: LONG y, ! 662: RECTL *prcl, ! 663: FLONG fl) ! 664: { ! 665: UINT i, j, k; ! 666: PBYTE pb; ! 667: WORD Cmd; ! 668: UINT cxMask, cyMask, cyAND, cyXOR, cxANDBytes, cxXORBytes; ! 669: UINT cxColor, cyColor; ! 670: PBYTE pjAND, pjXOR, pjColor; ! 671: LONG lDelta, lColorDelta; ! 672: PBYTE pb4Bpp; ! 673: UINT nSrcBytes; ! 674: PULONG pulXlate; ! 675: RECTL rclClip; ! 676: PPDEV ppdev; ! 677: BYTE LineBuff8Bpp[64]; ! 678: ! 679: DISPDBG((3, "S3.DLL:DrvSetColorPointerShape - Entry\n")); ! 680: ! 681: ppdev = (PPDEV) pso->dhpdev; ! 682: ! 683: // Sync this operation with the rest of the driver. ! 684: ! 685: GPWAIT(); ! 686: ! 687: // Remove the current pointer, if it is on the screen. ! 688: ! 689: if ((ppdev->flPointer & VALID_SAVE_BUFFER) && (!(ppdev->flPointer & ANIMATEUPDATE))) ! 690: { ! 691: DrvMovePointer(pso, -1, -1, NULL); ! 692: } ! 693: ! 694: // If the pointer is completely transparent, then just return. ! 695: ! 696: if (psoMask == NULL) ! 697: { ! 698: return (SPS_ACCEPT_EXCLUDE); ! 699: } ! 700: ! 701: // If the GDI requests the bounding box of the pointer, ! 702: // return it. ! 703: ! 704: if (prcl != NULL) ! 705: { ! 706: cxMask = psoMask->sizlBitmap.cx; ! 707: cyMask = psoMask->sizlBitmap.cy; ! 708: ! 709: prcl->left = x - xHot; ! 710: prcl->top = y - yHot; ! 711: prcl->right = prcl->left + cxMask; ! 712: prcl->bottom = prcl->top + cyMask; ! 713: ! 714: } ! 715: ! 716: // Set the clipping. ! 717: ! 718: rclClip.left = 0; ! 719: rclClip.top = COLOR_POINTER_Y; ! 720: rclClip.right = COLOR_POINTER_CX * 3; ! 721: rclClip.bottom = COLOR_POINTER_Y + COLOR_POINTER_CY; ! 722: ! 723: vSetS3ClipRect(ppdev, &rclClip); ! 724: ! 725: // Get the bitmap dimensions. ! 726: ! 727: cxMask = psoMask->sizlBitmap.cx; ! 728: cyMask = psoMask->sizlBitmap.cy; ! 729: ! 730: cxColor = psoColor->sizlBitmap.cx; ! 731: cyColor = psoColor->sizlBitmap.cy; ! 732: ! 733: cyAND = cyXOR = cyMask / 2; ! 734: cxANDBytes = cxXORBytes = cxMask / 8; ! 735: ! 736: // Set up pointers to the AND and XOR masks. ! 737: ! 738: pjAND = psoMask->pvScan0; ! 739: lDelta = psoMask->lDelta; ! 740: pjXOR = pjAND + (cyAND * lDelta); ! 741: ! 742: pjColor = psoColor->pvScan0; ! 743: lColorDelta = psoColor->lDelta; ! 744: ! 745: // Zero out coprocessor memory for the masks, color data, ! 746: // and the work area. Be carefull not to wipe out the save area. ! 747: ! 748: Cmd = RECTANGLE_FILL | ! 749: DRAW | DRAWING_DIR_TBLRXM | DIR_TYPE_XY | ! 750: LAST_PIXEL_ON | SINGLE_PIXEL | WRITE; ! 751: ! 752: FIFOWAIT(FIFO_3_EMPTY); ! 753: ! 754: TEST_AND_SET_FRGD_MIX(LOGICAL_0); ! 755: TEST_AND_SET_WRT_MASK(0xff); ! 756: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 757: ! 758: FIFOWAIT(FIFO_5_EMPTY); ! 759: ! 760: OUTPW(CUR_X, 0); ! 761: OUTPW(CUR_Y, COLOR_POINTER_Y); ! 762: OUTPW(RECT_WIDTH, (COLOR_POINTER_CX * 2) - 1); ! 763: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | COLOR_POINTER_CY - 1)); ! 764: OUTPW(CMD, Cmd); ! 765: ! 766: // Copy the AND mask to the off screen memory. ! 767: ! 768: Cmd = RECTANGLE_FILL | BUS_SIZE_8 | WAIT | ! 769: DRAW | DRAWING_DIR_TBLRXM | DIR_TYPE_XY | ! 770: LAST_PIXEL_ON | MULTIPLE_PIXELS | WRITE; ! 771: ! 772: ! 773: FIFOWAIT(FIFO_6_EMPTY); ! 774: ! 775: TEST_AND_SET_FRGD_MIX(FOREGROUND_COLOR | OVERPAINT); ! 776: TEST_AND_SET_FRGD_COLOR(0xff); ! 777: TEST_AND_SET_BKGD_MIX(BACKGROUND_COLOR | OVERPAINT); ! 778: SET_BKGD_COLOR(0x00); ! 779: TEST_AND_SET_WRT_MASK(COLOR_POINTER_AND_PLANE); ! 780: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | CPU_DATA)); ! 781: ! 782: FIFOWAIT(FIFO_5_EMPTY); ! 783: ! 784: OUTPW(CUR_X, 0); ! 785: OUTPW(CUR_Y, COLOR_POINTER_Y); ! 786: OUTPW(RECT_WIDTH, cxMask - 1); ! 787: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | cyAND - 1)); ! 788: ! 789: GPWAIT(); ! 790: ! 791: OUTPW(CMD, Cmd); ! 792: ! 793: CHECK_DATA_READY; ! 794: ! 795: // Now transfer the AND mask data. ! 796: ! 797: FIFOWAIT(FIFO_8_EMPTY); ! 798: ! 799: pb = pjAND; ! 800: for (i = 0; i < cyAND; i++) ! 801: { ! 802: vDataPortOutB(ppdev,(PBYTE) pb, cxANDBytes); ! 803: pb += lDelta; ! 804: } ! 805: ! 806: CHECK_DATA_COMPLETE; ! 807: ! 808: ! 809: // Copy the XOR mask to the off screen memory. ! 810: ! 811: Cmd = RECTANGLE_FILL | BUS_SIZE_8 | WAIT | ! 812: DRAW | DRAWING_DIR_TBLRXM | DIR_TYPE_XY | ! 813: LAST_PIXEL_ON | MULTIPLE_PIXELS | WRITE; ! 814: ! 815: FIFOWAIT(FIFO_6_EMPTY); ! 816: ! 817: TEST_AND_SET_FRGD_MIX(FOREGROUND_COLOR | OVERPAINT); ! 818: TEST_AND_SET_FRGD_COLOR(0xff); ! 819: TEST_AND_SET_BKGD_MIX(BACKGROUND_COLOR | OVERPAINT); ! 820: SET_BKGD_COLOR(0x00); ! 821: TEST_AND_SET_WRT_MASK(COLOR_POINTER_XOR_PLANE); ! 822: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | CPU_DATA)); ! 823: ! 824: FIFOWAIT(FIFO_5_EMPTY); ! 825: ! 826: OUTPW(CUR_X, 0); ! 827: OUTPW(CUR_Y, COLOR_POINTER_Y); ! 828: OUTPW(RECT_WIDTH, cxMask - 1); ! 829: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | cyXOR - 1)); ! 830: ! 831: GPWAIT(); ! 832: ! 833: OUTPW(CMD, Cmd); ! 834: ! 835: // Now transfer the XOR mask data. ! 836: ! 837: FIFOWAIT(FIFO_8_EMPTY); ! 838: ! 839: pb = pjXOR; ! 840: for (i = 0; i < cyXOR; i++) ! 841: { ! 842: vDataPortOutB(ppdev,(PBYTE) pb, cxXORBytes); ! 843: pb += lDelta; ! 844: } ! 845: ! 846: FIFOWAIT(FIFO_1_EMPTY); ! 847: ! 848: TEST_AND_SET_WRT_MASK(0xff); ! 849: ! 850: if (psoColor->iBitmapFormat == BMF_8BPP) ! 851: { ! 852: // Copy the Color mask to the off screen memory. ! 853: ! 854: Cmd = RECTANGLE_FILL | BUS_SIZE_8 | WAIT | ! 855: DRAW | DRAWING_DIR_TBLRXM | DIR_TYPE_XY | ! 856: LAST_PIXEL_ON | SINGLE_PIXEL | WRITE; ! 857: ! 858: FIFOWAIT(FIFO_7_EMPTY); ! 859: ! 860: TEST_AND_SET_FRGD_MIX(SRC_CPU_DATA | OVERPAINT); ! 861: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 862: OUTPW(CUR_X, COLOR_POINTER_CX); ! 863: OUTPW(CUR_Y, COLOR_POINTER_Y); ! 864: OUTPW(RECT_WIDTH, cxColor - 1); ! 865: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | cyColor - 1)); ! 866: ! 867: GPWAIT(); ! 868: ! 869: OUTPW(CMD, Cmd); ! 870: ! 871: CHECK_DATA_READY; ! 872: ! 873: // Now transfer the data. ! 874: ! 875: // Note: It would nice to do the entire bitmap in one ! 876: // fell swoop, but there is no gaurantee source will ! 877: // wrap on a bitmap boundary. ! 878: ! 879: FIFOWAIT(FIFO_8_EMPTY); ! 880: ! 881: pb = pjColor; ! 882: for (i = 0; i < cyColor; i++) ! 883: { ! 884: vDataPortOutB(ppdev,pb, cxColor); ! 885: pb += lColorDelta; ! 886: } ! 887: ! 888: CHECK_DATA_COMPLETE; ! 889: } ! 890: else ! 891: { ! 892: Cmd = RECTANGLE_FILL | BUS_SIZE_8 | WAIT | ! 893: DRAW | DRAWING_DIR_TBLRXM | DIR_TYPE_XY | ! 894: LAST_PIXEL_ON | SINGLE_PIXEL | WRITE; ! 895: ! 896: FIFOWAIT(FIFO_7_EMPTY); ! 897: ! 898: TEST_AND_SET_FRGD_MIX(SRC_CPU_DATA | OVERPAINT); ! 899: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 900: OUTPW(CUR_X, COLOR_POINTER_CX); ! 901: OUTPW(CUR_Y, COLOR_POINTER_Y); ! 902: OUTPW(RECT_WIDTH, cxColor - 1); ! 903: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | cyColor - 1)); ! 904: ! 905: GPWAIT(); ! 906: ! 907: OUTPW(CMD, Cmd); ! 908: ! 909: CHECK_DATA_READY; ! 910: ! 911: // Now transfer the data. ! 912: ! 913: // Note: It would nice to do the entire bitmap in one ! 914: // fell swoop, but there is no gaurantee source will ! 915: // wrap on a bitmap boundary. ! 916: ! 917: pb4Bpp = pjColor; ! 918: nSrcBytes = (cxColor + 1) / 2; ! 919: ! 920: if (pxlo->flXlate & XO_TABLE) ! 921: { ! 922: pulXlate = pxlo->pulXlate; ! 923: } ! 924: else ! 925: { ! 926: pulXlate = XLATEOBJ_piVector(pxlo); ! 927: } ! 928: ! 929: FIFOWAIT(FIFO_8_EMPTY); ! 930: ! 931: for (i = 0; i < cyColor; i++) ! 932: { ! 933: for (k = 0, j = 0; j < nSrcBytes; j++) ! 934: { ! 935: LineBuff8Bpp[k++] = (BYTE) pulXlate[(pb4Bpp[j] & 0xF0) >> 4]; ! 936: LineBuff8Bpp[k++] = (BYTE) pulXlate[pb4Bpp[j] & 0x0F]; ! 937: } ! 938: ! 939: vDataPortOutB(ppdev,LineBuff8Bpp, cxColor); ! 940: pb4Bpp += lColorDelta; ! 941: } ! 942: ! 943: CHECK_DATA_COMPLETE; ! 944: } ! 945: ! 946: // Set the position of the cursor. ! 947: ! 948: DrvMovePointer(pso, x, y, NULL); ! 949: ! 950: return (SPS_ACCEPT_EXCLUDE); ! 951: } ! 952: ! 953: /***************************************************************************** ! 954: * DrvSetMonoHwPointerShape - ! 955: ****************************************************************************/ ! 956: ULONG DrvSetMonoHwPointerShape( ! 957: SURFOBJ *pso, ! 958: SURFOBJ *psoMask, ! 959: SURFOBJ *psoColor, ! 960: XLATEOBJ *pxlo, ! 961: LONG xHot, ! 962: LONG yHot, ! 963: LONG x, ! 964: LONG y, ! 965: RECTL *prcl, ! 966: FLONG fl) ! 967: { ! 968: UINT i, j, k, cxMask, cyMask, cyAND, cxAND, cyXOR, cxXOR; ! 969: PBYTE pjAND, pjXOR; ! 970: PWORD pwS3AndMask, pwS3XorMask, pInterleavedMasks; ! 971: WORD msb, lsb; ! 972: INT lDelta; ! 973: PPDEV ppdev; ! 974: WORD PointerDataY; ! 975: BYTE s3AndMask[64][8], ! 976: s3XorMask[64][8]; ! 977: WORD s3InterleavedMasks[512]; ! 978: ! 979: DISPDBG((3, "S3.DLL:DrvSetMonoHwPointerShape - Entry\n")); ! 980: ! 981: ppdev = (PPDEV) pso->dhpdev; ! 982: ! 983: // If the mask is NULL this implies the pointer is not ! 984: // visible. ! 985: ! 986: if (psoMask == NULL) ! 987: { ! 988: OUTPW (CRTC_INDEX, (ppdev->HgcMode & ~(HGC_ENABLE << 8))); ! 989: return (SPS_ACCEPT_NOEXCLUDE); ! 990: } ! 991: ! 992: // Init the AND and XOR masks. ! 993: ! 994: memset (s3AndMask, 0xFF, 512); ! 995: memset (s3XorMask, 0x00, 512); ! 996: ! 997: // Get the bitmap dimensions. ! 998: ! 999: cxMask = psoMask->sizlBitmap.cx; ! 1000: cyMask = psoMask->sizlBitmap.cy; ! 1001: ! 1002: cyAND = cyXOR = cyMask / 2; ! 1003: cxAND = cxXOR = cxMask / 8; ! 1004: ! 1005: // Set up pointers to the AND and XOR masks. ! 1006: ! 1007: pjAND = psoMask->pvScan0; ! 1008: lDelta = psoMask->lDelta; ! 1009: pjXOR = pjAND + (cyAND * lDelta); ! 1010: ! 1011: // Copy the AND mask. ! 1012: ! 1013: memset (s3AndMask, 0xFFFFFFFF, 512); ! 1014: memset (s3XorMask, 0, 512); ! 1015: ! 1016: for (i = 0; i < cyAND; i++) ! 1017: { ! 1018: // Copy over a line of the AND mask. ! 1019: ! 1020: for (j = 0; j < cxAND; j++) ! 1021: { ! 1022: s3AndMask[i][j] = pjAND[j]; ! 1023: } ! 1024: ! 1025: // point to the next line of the AND mask. ! 1026: ! 1027: pjAND += lDelta; ! 1028: } ! 1029: ! 1030: // Copy the XOR mask. ! 1031: ! 1032: for (i = 0; i < cyXOR; i++) ! 1033: { ! 1034: // Copy over a line of the XOR mask. ! 1035: ! 1036: for (j = 0; j < cxXOR; j++) ! 1037: { ! 1038: s3XorMask[i][j] = pjXOR[j]; ! 1039: } ! 1040: ! 1041: // point to the next line of the XOR mask. ! 1042: ! 1043: pjXOR += lDelta; ! 1044: } ! 1045: ! 1046: // Interleave the S3AND and S3XOR masks. ! 1047: // This will allow an rep stosw instruction to down ! 1048: // load the mask to the card.. ! 1049: ! 1050: pwS3AndMask = (PWORD) s3AndMask; ! 1051: pwS3XorMask = (PWORD) s3XorMask; ! 1052: pInterleavedMasks = s3InterleavedMasks; ! 1053: ! 1054: // Interleave the S3AND and S3XOR masks. ! 1055: // This will allow an rep stosw instruction to down ! 1056: // load the mask to the card.. ! 1057: ! 1058: pwS3AndMask = (PWORD) s3AndMask; ! 1059: pwS3XorMask = (PWORD) s3XorMask; ! 1060: pInterleavedMasks = s3InterleavedMasks; ! 1061: ! 1062: k = 256; ! 1063: ! 1064: for (i = 0; i < k; i++) ! 1065: { ! 1066: *pInterleavedMasks++ = *pwS3AndMask++; ! 1067: *pInterleavedMasks++ = *pwS3XorMask++; ! 1068: } ! 1069: ! 1070: // Down load the pointer shape to the S3 chip. ! 1071: // Determine Which Monochrome pointer buffer is available. ! 1072: ! 1073: if (ppdev->MonoPointerData == 0) ! 1074: { ! 1075: PointerDataY = LOWORD (PTR_DATA_Y); ! 1076: ppdev->MonoPointerData = 1; ! 1077: } ! 1078: else ! 1079: { ! 1080: PointerDataY = LOWORD (PTR_DATA_Y - 1); ! 1081: ppdev->MonoPointerData = 0; ! 1082: } ! 1083: ! 1084: // Set the clipping window to include the last line of offscreen ! 1085: // memory. ! 1086: ! 1087: vResetS3Clipping(ppdev); ! 1088: ! 1089: // Wait for Fifo 7 to empty. ! 1090: ! 1091: FIFOWAIT(FIFO_7_EMPTY); ! 1092: ! 1093: // Now set up for the rectangle. ! 1094: ! 1095: OUTPW (CUR_X, PTR_DATA_X); ! 1096: OUTPW (CUR_Y, PointerDataY); ! 1097: ! 1098: OUTPW (RECT_WIDTH, ppdev->cxMaxRam - 1); ! 1099: OUTPW (MULTIFUNC_CNTL, RECT_HEIGHT); ! 1100: ! 1101: OUTPW (MULTIFUNC_CNTL, DATA_EXTENSION); ! 1102: ! 1103: TEST_AND_SET_FRGD_MIX(SRC_CPU_DATA | OVERPAINT); ! 1104: ! 1105: GPWAIT(); ! 1106: ! 1107: OUTPW (CMD, (RECTANGLE_FILL | BYTE_SWAP | ! 1108: BUS_SIZE_16 | WAIT | ! 1109: DRAWING_DIR_TBLRXM | ! 1110: DRAW | WRITE)); ! 1111: ! 1112: CHECK_DATA_READY; ! 1113: ! 1114: // Now down load the masks. ! 1115: ! 1116: vDataPortOut(ppdev, (PWORD) s3InterleavedMasks, 512); ! 1117: ! 1118: CHECK_DATA_COMPLETE; ! 1119: ! 1120: // This should do it. (the cursor should be downloaded) ! 1121: // Now, wasn't that simple, NOT! ! 1122: ! 1123: // Note: At one point we disabled the pointer before setting the new one. ! 1124: // this caused an excessive flicker of the pointer, so we removed the disable. ! 1125: // At another point, we found the cursor jumped to the left for 1 frame if ! 1126: // we did not disable the cursor for non-animated pointers. So, now ! 1127: // we handle each case separately. ! 1128: ! 1129: ! 1130: if (!(ppdev->flPointer & ANIMATEUPDATE)) ! 1131: { ! 1132: OUTPW (CRTC_INDEX, (ppdev->HgcMode | (HGC_DISABLE << 8))); ! 1133: } ! 1134: ! 1135: // Set the hardware graphics cursor storage area start address for ! 1136: // the new pointer data. ! 1137: ! 1138: msb = HIBYTE (PointerDataY); ! 1139: lsb = LOBYTE (PointerDataY); ! 1140: ! 1141: OUTPW (CRTC_INDEX, ((msb << 8) | CR4C)); ! 1142: OUTPW (CRTC_INDEX, ((lsb << 8) | CR4D)); ! 1143: ! 1144: // Set the position of the cursor. ! 1145: // Need to do this twice, due to shadowing in the 928 and 801/805. ! 1146: ! 1147: DrvMoveHwPointer(pso, x, y, NULL); ! 1148: ! 1149: // On the 928, 801/805 wait for vertical interval then set the ! 1150: // position a second time. ! 1151: ! 1152: if (ppdev->s3ChipID >= 0x90) ! 1153: { ! 1154: while (INP(STATUS_1) & VSY_NOT); ! 1155: DrvMoveHwPointer(pso, x, y, NULL); ! 1156: ! 1157: while (!(INP(STATUS_1) & VSY_NOT)); ! 1158: DrvMoveHwPointer(pso, x, y, NULL); ! 1159: ! 1160: } ! 1161: ! 1162: OUTPW (CRTC_INDEX, (ppdev->HgcMode | (HGC_ENABLE << 8))); ! 1163: ! 1164: // Reset the clipping. This can go when no H/W clipping is done ! 1165: // on the color pointer. ! 1166: ! 1167: vResetS3Clipping(ppdev); ! 1168: ! 1169: return (SPS_ACCEPT_NOEXCLUDE); ! 1170: } ! 1171: ! 1172: ! 1173: ! 1174: /***************************************************************************** ! 1175: * DrvSetBt485PointerShape - ! 1176: ****************************************************************************/ ! 1177: ULONG DrvSetBt485PointerShape( ! 1178: SURFOBJ *pso, ! 1179: SURFOBJ *psoMask, ! 1180: SURFOBJ *psoColor, ! 1181: XLATEOBJ *pxlo, ! 1182: LONG xHot, ! 1183: LONG yHot, ! 1184: LONG x, ! 1185: LONG y, ! 1186: RECTL *prcl, ! 1187: FLONG fl) ! 1188: { ! 1189: UINT i, j, cxMask, cyMask, cyAND, cxAND, cyXOR, cxXOR; ! 1190: PBYTE pjAND, pjXOR; ! 1191: INT lDelta; ! 1192: PPDEV ppdev; ! 1193: BYTE s3AndMask[64][8], ! 1194: s3XorMask[64][8]; ! 1195: ! 1196: DISPDBG((3, "S3.DLL:DrvSetBt485PointerShape - Entry\n")); ! 1197: ! 1198: ppdev = (PPDEV) pso->dhpdev; ! 1199: ! 1200: // If the mask is NULL this implies the pointer is not ! 1201: // visible. ! 1202: ! 1203: if (psoMask == NULL) ! 1204: { ! 1205: // Disable the H/W cursor on the Bt 485. ! 1206: ! 1207: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0200)); ! 1208: OUTP (BT485_ADDR_CMD_REG2, ppdev->Bt485CmdReg2 & BT485_CURSOR_DISABLE); ! 1209: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl)); ! 1210: ! 1211: return (SPS_ACCEPT_NOEXCLUDE); ! 1212: } ! 1213: ! 1214: // Init the AND and XOR masks. ! 1215: ! 1216: memset (s3AndMask, 0xFF, 512); ! 1217: memset (s3XorMask, 0x00, 512); ! 1218: ! 1219: // Get the bitmap dimensions. ! 1220: ! 1221: cxMask = psoMask->sizlBitmap.cx; ! 1222: cyMask = psoMask->sizlBitmap.cy; ! 1223: ! 1224: cyAND = cyXOR = cyMask / 2; ! 1225: cxAND = cxXOR = cxMask / 8; ! 1226: ! 1227: // Set up pointers to the AND and XOR masks. ! 1228: ! 1229: pjAND = psoMask->pvScan0; ! 1230: lDelta = psoMask->lDelta; ! 1231: pjXOR = pjAND + (cyAND * lDelta); ! 1232: ! 1233: // Copy the AND mask. ! 1234: ! 1235: for (i = 0; i < cyAND; i++) ! 1236: { ! 1237: // Copy over a line of the AND mask. ! 1238: ! 1239: for (j = 0; j < cxAND; j++) ! 1240: { ! 1241: s3AndMask[i][j] = pjAND[j]; ! 1242: } ! 1243: ! 1244: // point to the next line of the AND mask. ! 1245: ! 1246: pjAND += lDelta; ! 1247: } ! 1248: ! 1249: // Copy the XOR mask. ! 1250: ! 1251: for (i = 0; i < cyXOR; i++) ! 1252: { ! 1253: // Copy over a line of the XOR mask. ! 1254: ! 1255: for (j = 0; j < cxXOR; j++) ! 1256: { ! 1257: s3XorMask[i][j] = pjXOR[j]; ! 1258: } ! 1259: ! 1260: // point to the next line of the XOR mask. ! 1261: ! 1262: pjXOR += lDelta; ! 1263: } ! 1264: ! 1265: pjAND = (PBYTE) s3AndMask; ! 1266: pjXOR = (PBYTE) s3XorMask; ! 1267: ! 1268: // Set the cursor for 64 X 64, and set the 2 MSB's for the cursor ! 1269: // RAM addr to 0. ! 1270: // First get access to Command Register 3 ! 1271: ! 1272: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0100)); ! 1273: OUTP (BT485_ADDR_CMD_REG0, ppdev->Bt485CmdReg0 | BT485_CMD_REG_3_ACCESS); ! 1274: ! 1275: OUTPW (CRTC_INDEX, ppdev->ExtDacCtl); ! 1276: OUTP (0x3c8, 0x01); ! 1277: ! 1278: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0200)); ! 1279: OUTP (BT485_ADDR_CMD_REG3, ppdev->Bt485CmdReg3); ! 1280: ! 1281: // Disable the H/W cursor on the Bt 485. ! 1282: ! 1283: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0200)); ! 1284: OUTP (BT485_ADDR_CMD_REG2, ppdev->Bt485CmdReg2 & BT485_CURSOR_DISABLE); ! 1285: ! 1286: // Down load the AND mask ! 1287: ! 1288: OUTPW (CRTC_INDEX, ppdev->ExtDacCtl); ! 1289: OUTP (BT485_ADDR_CUR_RAM_WRITE, 0x0); ! 1290: ! 1291: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0200)); ! 1292: ! 1293: // Down load the XOR mask ! 1294: ! 1295: for (i = 0 ; i < 512 ; i++) ! 1296: { ! 1297: OUTP (BT485_CUR_RAM_ARRAY_DATA, pjXOR[i]); ! 1298: } ! 1299: ! 1300: // Down load the AND mask ! 1301: ! 1302: for (i = 0 ; i < 512 ; i++) ! 1303: { ! 1304: OUTP (BT485_CUR_RAM_ARRAY_DATA, pjAND[i]); ! 1305: } ! 1306: ! 1307: // Set the position of the cursor. ! 1308: // Need to do this twice, due to shadowing in the 928 and 801/805. ! 1309: ! 1310: DrvMoveBt485Pointer(pso, x, y, NULL); ! 1311: ! 1312: // Enable the H/W cursor ! 1313: ! 1314: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0200)); ! 1315: OUTP (BT485_ADDR_CMD_REG2, ppdev->Bt485CmdReg2 | BT485_CURSOR_MODE2); ! 1316: ! 1317: // Reset DAC extended registers. ! 1318: ! 1319: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl)); ! 1320: ! 1321: return (SPS_ACCEPT_NOEXCLUDE); ! 1322: } ! 1323: ! 1324: ! 1325: ! 1326:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.