![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bankmgr.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 bankmgr.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / s3 |
1.1 root 1: /******************************************************************************
2: *
3: * S3 Bank Manager
4: *
5: * Copyright (c) 1992 Microsoft Corporation
6: *****************************************************************************/
7:
8: #include "driver.h"
9:
10: // Bank select forward prototype.
11:
12: VOID vSetS3Bank(PPDEV ppdev, UINT iBank);
13:
14: /******************************************************************************
15: * bBankInit - Initialize the bank manager.
16: *
17: * Setup the ppdev->arclBanks Array. Since this driver is chip specific,
18: * we can take a number of short cuts. We know there will always
19: * be 1 meg of memory on the board, and there will only be 1 64K R/W
20: * bank.
21: *
22: *****************************************************************************/
23: BOOL bBankInit(
24: PPDEV ppdev,
25: BOOL fFirstTime)
26: {
27: INT i;
28: BYTE jMemCfg;
29:
30: DISPDBG((3, "S3.DLL: bBankInit - Entry\n"));
31:
32: if (fFirstTime)
33: {
34: ppdev->BankSize = MEMORY_APERTURE_SIZE;
35: ppdev->ScansPerBank = ppdev->BankSize / ppdev->cxMaxRam;
36: ppdev->MaxBanks = ppdev->cyMaxRam / ppdev->ScansPerBank;
37:
38: ppdev->prclBanks = LocalAlloc(LPTR, ppdev->MaxBanks * sizeof (RECT));
39: if (ppdev->prclBanks == NULL)
40: {
41: DISPDBG((0, "S3.DLL!bBankInit - LocalAlloc (prclBanks) failed \n"));
42: EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
43: return (FALSE);
44: }
45:
46: ppdev->pBanks = LocalAlloc(LPTR, ppdev->MaxBanks * sizeof (BANK));
47: if (ppdev->pBanks == NULL)
48: {
49: DISPDBG((0, "S3.DLL!bBankInit - LocalAlloc (pBanks) failed \n"));
50: EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
51: return (FALSE);
52: }
53:
54: // Note: We only care about scans for the S3 chip. So don't
55: // bother initializing the left and right sides of the rectangle.
56:
57: for (i = 0; i < ppdev->MaxBanks; i++) {
58: ppdev->prclBanks[i].top = i * ppdev->ScansPerBank;
59: ppdev->prclBanks[i].bottom = ppdev->prclBanks[i].top + ppdev->ScansPerBank;
60: }
61: }
62:
63: // Unlock some of the S3 registers.
64:
65: OUTPW (CRTC_INDEX, ((REG_UNLOCK_1 << 8) | S3R8));
66:
67: // Enable the Memory Aperture.
68:
69: OUTP(CRTC_INDEX, S3R1);
70: jMemCfg = INP(CRTC_DATA);
71: jMemCfg |= CPUA_BASE;
72: OUTP(CRTC_DATA, jMemCfg);
73:
74: // Get the initial value of S3R5 and save it away.
75: // This will prevent reading the Aperature control register
76: // each time we want to set the bank.
77:
78: OUTP(CRTC_INDEX, S3R5);
79: ppdev->jS3R5 = INP(CRTC_DATA);
80: ppdev->jS3R5 &= 0xF0; // Just mask for the bits we want.
81:
82: return(TRUE);
83: }
84:
85: /******************************************************************************
86: * bBankEnumStart - Start the bank enumeration.
87: *
88: * Save the original values for pvScan0 and rclBounds (The start of the
89: * engine managed bitmap and the clipping bounding rectangle.)
90: *
91: * Setup all the banks to enumerate in the ppdev->pBanks array.
92: * Setup the first bank to enumerate.
93: *
94: * Entry: prclScan->bottom - Ptr to the top (first) scan to render (inclusive)
95: * prclScan->top - Ptr to the bottom (last) scan to render (inclusive)
96: * pso - The surface object.
97: * pco - The clipping object.
98: *
99: * Exit: TRUE - if any rendering needs to be done.
100: * FALSE - if there is nothing to render, (i.e. the object
101: * is completely clipped out.)
102: * prclScan->bottom - The Top Scan to render into.
103: * prclScan->top - The Bottom Scan to render into.
104: *
105: *****************************************************************************/
106: BOOL bBankEnumStart(
107: PPDEV ppdev,
108: PRECTL prclScans,
109: SURFOBJ *pso,
110: CLIPOBJ *pco)
111: {
112: LONG TopScan, BottomScan, BankBottom;
113: PBYTE pbScan0;
114: INT i, iFirstBank, iLastBank;
115:
116: DISPDBG((3, "S3.DLL: bBankEnumStart - Entry\n"));
117:
118: // Save the original pvScan0 and the ClipObj's rclBounds.
119:
120: ppdev->pvOrgScan0 = pso->pvScan0;
121: ppdev->rclOrgBounds = pco->rclBounds;
122: ppdev->iOrgDComplexity = pco->iDComplexity;
123: ppdev->fjOptions = pco->fjOptions;
124:
125: // Set the flag in the clip object to tell the engine to forcible
126: // clip to the rclBounds of the clip object.
127:
128: pco->fjOptions |= OC_BANK_CLIP;
129:
130: // If the clipping is not trivial, do an intersection of the
131: // top & bottom scans with the clipping bounds.
132:
133: if (pco->iDComplexity != DC_TRIVIAL)
134: {
135: TopScan = max (pco->rclBounds.top, prclScans->top);
136: BottomScan = min (pco->rclBounds.bottom, prclScans->bottom);
137: }
138: else
139: {
140: TopScan = prclScans->top;
141: BottomScan = prclScans->bottom;
142: }
143:
144: // Init the variables used to set up the banks.
145:
146: iLastBank = -1;
147: ppdev->cBanks = 0;
148: ppdev->iBank = 0;
149: pbScan0 = (PBYTE) pso->pvScan0;
150:
151: // Find the bank that contains the top scan (the first bank).
152:
153: for (i = 0; i < ppdev->MaxBanks; i++)
154: {
155: BankBottom = ppdev->prclBanks[i].bottom;
156: if (BankBottom > TopScan)
157: {
158: // The Top scan is within this bank,
159:
160: iFirstBank = i;
161:
162: // Set up the bank entry.
163:
164: ppdev->pBanks[ppdev->iBank].pvScan0 = pbScan0 - (i * ppdev->BankSize);
165: ppdev->pBanks[ppdev->iBank].Bank = i;
166: ppdev->pBanks[ppdev->iBank].rclClip.top = TopScan;
167:
168: if (BankBottom < BottomScan)
169: {
170: ppdev->pBanks[ppdev->iBank].rclClip.bottom = BankBottom;
171: }
172: else
173: {
174: ppdev->pBanks[ppdev->iBank].rclClip.bottom = BottomScan;
175: iLastBank = iFirstBank;
176: }
177:
178: // Set the left and right bounds of the bank clip rect.
179:
180: ppdev->pBanks[ppdev->iBank].rclClip.left = pco->rclBounds.left;
181: ppdev->pBanks[ppdev->iBank].rclClip.right = pco->rclBounds.right;
182:
183: // Bump bank array index to next entry and the bank
184: // count.
185:
186: ppdev->iBank++;
187: ppdev->cBanks++;
188:
189: // Since we found the first bank, bail out of this loop.
190:
191: break;
192:
193: }
194: }
195:
196: if (i == ppdev->MaxBanks) {
197:
198: RIP("S3.DLL: bBankEnumStart - error \n");
199: return FALSE;
200: }
201:
202: if (iLastBank != iFirstBank)
203: {
204: // Set the last bank to the first bank in case there are no
205: // middle banks.
206:
207: iLastBank = iFirstBank;
208:
209: // Take care of all the middle banks.
210:
211: for (i = iFirstBank+1; i < ppdev->MaxBanks; i++)
212: {
213: if (ppdev->prclBanks[i].bottom < BottomScan)
214: {
215: // This bank is completely within the rendering rectangle.
216:
217: ppdev->pBanks[ppdev->iBank].pvScan0 = pbScan0 - (i * ppdev->BankSize);
218: ppdev->pBanks[ppdev->iBank].Bank = i;
219: ppdev->pBanks[ppdev->iBank].rclClip.top = ppdev->prclBanks[i].top;
220: ppdev->pBanks[ppdev->iBank].rclClip.bottom = ppdev->prclBanks[i].bottom;
221:
222: // Set the left and right bounds of the bank clip rect.
223:
224: ppdev->pBanks[ppdev->iBank].rclClip.left = pco->rclBounds.left;
225: ppdev->pBanks[ppdev->iBank].rclClip.right = pco->rclBounds.right;
226:
227: // Bump bank array index to next entry and the bank
228: // count.
229:
230: ppdev->iBank++;
231: ppdev->cBanks++;
232:
233: iLastBank = i;
234: }
235: else
236: {
237: // The bottom of the bank we're currently "looking" at is
238: // below (greater in value) than the bottom of the rectangle
239: // were rendering, so there we're done looking at the middle
240: // banks.
241:
242: break;
243: }
244: }
245:
246: // Now take care of the last bank.
247:
248: iLastBank++;
249:
250: if (ppdev->prclBanks[iLastBank].top < BottomScan)
251: {
252: ppdev->pBanks[ppdev->iBank].pvScan0 = pbScan0 - (iLastBank * ppdev->BankSize);
253: ppdev->pBanks[ppdev->iBank].Bank = iLastBank;
254:
255: ppdev->pBanks[ppdev->iBank].rclClip.top = ppdev->prclBanks[iLastBank].top;
256: ppdev->pBanks[ppdev->iBank].rclClip.bottom = BottomScan;
257:
258: ppdev->pBanks[ppdev->iBank].rclClip.left = pco->rclBounds.left;
259: ppdev->pBanks[ppdev->iBank].rclClip.right = pco->rclBounds.right;
260:
261: ppdev->cBanks++;
262:
263: }
264: }
265:
266: // We need to make sure the clipping level is at least DC_RECT.
267: // Some code in the engine (like EngCopybits) will ignore the
268: // clip rectangle entirely if the level is DC_TRIVIAL.
269:
270: if (pco->iDComplexity == DC_TRIVIAL)
271: pco->iDComplexity = DC_RECT;
272:
273: // Now take care of setting the first bank
274:
275: ppdev->iBank = 1; // set the next bank index
276: ppdev->cBanks--; // set # of remaining banks
277:
278: // Set the top and bottom scans for the caller
279:
280: prclScans->top = ppdev->pBanks[0].rclClip.top; // set top scan.
281: prclScans->bottom = ppdev->pBanks[0].rclClip.bottom; // set bottom scan.
282:
283: // Set the S3 chip.
284:
285: vSetS3Bank(ppdev, ppdev->pBanks[0].Bank);
286:
287: // Set the clip rectangle for the engine.
288:
289: pco->rclBounds = ppdev->pBanks[0].rclClip;
290:
291: // Set pvScan0 for the engine.
292:
293: pso->pvScan0 = ppdev->pBanks[0].pvScan0;
294:
295: ENABLE_DIRECT_ACCESS;
296:
297: return (TRUE);
298: }
299:
300: /******************************************************************************
301: * bSrcBankEnumStart - Start the bank enumeration when the screen is the
302: * source
303: *
304: * Save the original values for pvScan0 and rclBounds (The start of the
305: * engine managed bitmap and the clipping bounding rectangle.)
306: *
307: * Setup all the banks to enumerate in the ppdev->pBanks array.
308: * Setup the first bank to enumerate.
309: *
310: * Entry: prclScan->bottom - Ptr to the top (first) scan to render (inclusive)
311: * prclScan->top - Ptr to the bottom (last) scan to render (inclusive)
312: * pso - The surface object.
313: * pco - The clipping object.
314: *
315: * Exit: TRUE - if any rendering needs to be done.
316: * FALSE - if there is nothing to render, (i.e. the object
317: * is completely clipped out.)
318: * prclScan->bottom - The Top Scan to render into.
319: * prclScan->top - The Bottom Scan to render into.
320: *
321: * NOTE: This routine is a little trickier than bBankEnumStart. We make GDI
322: * read only the current bank by altering the CLIPOBJ before passing the
323: * call back to GDI. The problem here is that the CLIPOBJ applies only to the
324: * destination, but for this case it's the screen that is the source. So we
325: * have to adjust for this accordingly.
326: *
327: *****************************************************************************/
328: BOOL bSrcBankEnumStart(
329: PPDEV ppdev,
330: PRECTL prclScans,
331: SURFOBJ *pso,
332: CLIPOBJ *pco,
333: PRECTL prclDest)
334: {
335: LONG TopScan, BottomScan, BankBottom;
336: PBYTE pbScan0;
337: INT i, iFirstBank, iLastBank, cyFirstBank, cyMiddleBanks;
338: RECTL rclBounds;
339:
340: DISPDBG((3, "S3.DLL: bSrcBankEnumStart - Entry\n"));
341:
342: // Save the original pvScan0 and the ClipObj's rclBounds.
343:
344: ppdev->pvOrgScan0 = pso->pvScan0;
345: ppdev->rclOrgBounds = pco->rclBounds;
346: ppdev->iOrgDComplexity = pco->iDComplexity;
347: ppdev->fjOptions = pco->fjOptions;
348:
349: // If the clipping is not trivial, do an intersection of the
350: // Set the flag in the clip object to tell the engine to forcible
351: // clip to the rclBounds of the clip object.
352:
353: pco->fjOptions |= OC_BANK_CLIP;
354:
355: // top & bottom scans with the clipping bounds.
356:
357: // NOTE: Since the Scans rectangle and the clipping rectangle
358: // refer to two different surfaces, we will always use the
359: // the Scans rectangle to determine the bank(s) we need to
360: // enumerate.
361:
362: // rclBounds keeps track of the y-extents of the destination, and is
363: // calculated from the intersection of the destination rectangle
364: // and the CLIPOBJ's bounds:
365:
366: if (pco->iDComplexity != DC_TRIVIAL)
367: {
368: rclBounds.top = max(prclDest->top, pco->rclBounds.top);
369: rclBounds.bottom = min(prclDest->bottom, pco->rclBounds.bottom);
370: }
371: else
372: {
373: rclBounds.top = prclDest->top;
374: rclBounds.bottom = prclDest->bottom;
375: }
376:
377: // TopScan and BottomScan keep track of the corresponding y-extents of
378: // the source:
379:
380: TopScan = prclScans->top + (rclBounds.top - prclDest->top);
381: BottomScan = prclScans->bottom + (rclBounds.bottom - prclDest->bottom);
382:
383: // Init the variables used to set up the banks.
384:
385: iLastBank = -1;
386: ppdev->cBanks = 0;
387: ppdev->iBank = 0;
388: pbScan0 = (PBYTE) pso->pvScan0;
389:
390: // Find the bank that contains the top scan (the first bank).
391:
392: for (i = 0; i < ppdev->MaxBanks; i++)
393: {
394: BankBottom = ppdev->prclBanks[i].bottom;
395: if (BankBottom > TopScan)
396: {
397: // The Top scan is within this bank,
398:
399: iFirstBank = i;
400:
401: // Set up the bank entry.
402:
403: ppdev->pBanks[ppdev->iBank].pvScan0 = pbScan0 - (i * ppdev->BankSize);
404: ppdev->pBanks[ppdev->iBank].Bank = i;
405: ppdev->pBanks[ppdev->iBank].rclClip.top = rclBounds.top;
406:
407: // Take care of the case where the entire operation
408: // fits within one bank.
409:
410: if (BankBottom < BottomScan)
411: {
412: // The operation spans more than this one bank.
413:
414: cyFirstBank = BankBottom - TopScan;
415: ppdev->pBanks[ppdev->iBank].rclClip.bottom = rclBounds.top + cyFirstBank;
416: }
417: else
418: {
419: // The operation is completel contained with in this
420: // single bank.
421:
422: ppdev->pBanks[ppdev->iBank].rclClip.bottom = rclBounds.bottom;
423: iLastBank = iFirstBank;
424: }
425:
426: // Set the left and right bounds of the bank clip rect.
427:
428: ppdev->pBanks[ppdev->iBank].rclClip.left = pco->rclBounds.left;
429: ppdev->pBanks[ppdev->iBank].rclClip.right = pco->rclBounds.right;
430:
431: // Bump bank array index to next entry and the bank
432: // count.
433:
434: ppdev->iBank++;
435: ppdev->cBanks++;
436:
437: // Since we found the first bank, bail out of this loop.
438:
439: break;
440:
441: }
442: }
443:
444: if (i == ppdev->MaxBanks) {
445:
446: RIP("S3.DLL: bSrcBankEnumStart - error \n");
447: return FALSE;
448: }
449:
450: if (iLastBank != iFirstBank)
451: {
452: // Set the last bank to the first bank in case there are no
453: // middle banks.
454:
455: iLastBank = iFirstBank;
456:
457: // Take care of all the middle banks.
458: // Update rclBounds for this bank.
459:
460: rclBounds.top += cyFirstBank;
461:
462: cyMiddleBanks = ppdev->ScansPerBank;
463: rclBounds.bottom = rclBounds.top + cyMiddleBanks;
464:
465: for (i = iFirstBank+1; i < ppdev->MaxBanks; i++)
466: {
467: if (ppdev->prclBanks[i].bottom < BottomScan)
468: {
469: // This bank is completely within the rendering rectangle.
470:
471: ppdev->pBanks[ppdev->iBank].pvScan0 = pbScan0 - (i * ppdev->BankSize);
472: ppdev->pBanks[ppdev->iBank].Bank = i;
473:
474: ppdev->pBanks[ppdev->iBank].rclClip.top = rclBounds.top;
475: ppdev->pBanks[ppdev->iBank].rclClip.bottom = rclBounds.bottom;
476:
477: // Set the left and right bounds of the bank clip rect.
478:
479: ppdev->pBanks[ppdev->iBank].rclClip.left = pco->rclBounds.left;
480: ppdev->pBanks[ppdev->iBank].rclClip.right = pco->rclBounds.right;
481:
482: // Update for the next bank bounds.
483:
484: rclBounds.top += cyMiddleBanks;
485:
486: rclBounds.bottom = rclBounds.top + cyMiddleBanks;
487:
488: // Bump bank array index to next entry and the bank
489: // count.
490:
491: ppdev->iBank++;
492: ppdev->cBanks++;
493:
494: iLastBank = i;
495:
496: }
497: }
498:
499: // Now take care of the last bank.
500:
501: iLastBank++;
502:
503: if (ppdev->prclBanks[iLastBank].top < BottomScan)
504: {
505: ppdev->pBanks[ppdev->iBank].pvScan0 = pbScan0 - (iLastBank * ppdev->BankSize);
506: ppdev->pBanks[ppdev->iBank].Bank = iLastBank;
507:
508: ppdev->pBanks[ppdev->iBank].rclClip.top = rclBounds.top;
509: ppdev->pBanks[ppdev->iBank].rclClip.bottom = rclBounds.bottom;
510:
511: ppdev->pBanks[ppdev->iBank].rclClip.left = pco->rclBounds.left;
512: ppdev->pBanks[ppdev->iBank].rclClip.right = pco->rclBounds.right;
513:
514: ppdev->cBanks++;
515:
516: }
517: }
518:
519: // We need to make sure the clipping level is at least DC_RECT.
520: // Some code in the engine (like EngCopybits) will ignore the
521: // clip rectangle entirely if the level is DC_TRIVIAL.
522:
523: if (pco->iDComplexity == DC_TRIVIAL)
524: pco->iDComplexity = DC_RECT;
525:
526: // Now take care of setting the first bank
527:
528: ppdev->iBank = 1; // set the next bank index
529: ppdev->cBanks--; // set # of remaining banks
530:
531: // Set the top and bottom scans for the caller
532:
533: prclScans->top = ppdev->pBanks[0].rclClip.top; // set top scan.
534: prclScans->bottom = ppdev->pBanks[0].rclClip.bottom; // set bottom scan.
535:
536: // Set the S3 chip.
537:
538: vSetS3Bank(ppdev, ppdev->pBanks[0].Bank);
539:
540: // Set the clip rectangle for the engine.
541:
542: pco->rclBounds = ppdev->pBanks[0].rclClip;
543:
544: // Set pvScan0 for the engine.
545:
546: pso->pvScan0 = ppdev->pBanks[0].pvScan0;
547:
548: ENABLE_DIRECT_ACCESS;
549:
550: return (TRUE);
551: }
552:
553: /******************************************************************************
554: * bBankEnum - Enumerate the next bank.
555: *
556: * Just enumerate the next bank. pvScan0, the clipping Rect, and the
557: * chip are all set up for this bank.
558: *
559: * Entry: none
560: *
561: * Exit: TRUE - if this bank needs any rendering.
562: * FALSE - if there is nothing to render.
563: *
564: * prclScans - The Scans to render into.
565: *
566: ******************************************************************************/
567: BOOL bBankEnum(
568: PPDEV ppdev,
569: PRECTL prclScans,
570: SURFOBJ *pso,
571: CLIPOBJ *pco)
572: {
573: DISPDBG((3, "S3.DLL: bBankEnum - Entry\n"));
574:
575: if (ppdev->cBanks == 0)
576: return (FALSE);
577:
578: // Set the top and bottom scans for the caller
579:
580: prclScans->top = ppdev->pBanks[ppdev->iBank].rclClip.top; // set top scan.
581: prclScans->bottom = ppdev->pBanks[ppdev->iBank].rclClip.bottom; // set bottom scan.
582:
583: // Set the S3 chip.
584:
585: vSetS3Bank(ppdev, ppdev->pBanks[ppdev->iBank].Bank);
586:
587: // Set the clip rectangle for the engine.
588:
589: pco->rclBounds = ppdev->pBanks[ppdev->iBank].rclClip;
590:
591: // Set pvScan0 for the engine.
592:
593: pso->pvScan0 = ppdev->pBanks[ppdev->iBank].pvScan0;
594:
595: // Update the bank index and bank count.
596:
597: ppdev->cBanks--;
598: ppdev->iBank++;
599:
600: return (TRUE);
601: }
602:
603: /******************************************************************************
604: * bBankEnumEnd - Finish the bank enumeration.
605: *
606: * Cleanup from the enumeration. This restores the original pvScan0 and
607: * ClipRectangle.
608: *
609: ******************************************************************************/
610: BOOL bBankEnumEnd(
611: PPDEV ppdev,
612: SURFOBJ *pso,
613: CLIPOBJ *pco)
614: {
615: DISPDBG((3, "S3.DLL: bBankEnumEnd - Entry\n"));
616:
617: pso->pvScan0 = ppdev->pvOrgScan0;
618: pco->rclBounds = ppdev->rclOrgBounds;
619: pco->iDComplexity = ppdev->iOrgDComplexity;
620: pco->fjOptions = ppdev->fjOptions;
621:
622: ENABLE_S3_ENGINE;
623:
624: return (TRUE);
625: }
626:
627:
628:
629:
630: /******************************************************************************
631: * vSetS3Bank - Set the bank on the S3 chip.
632: ******************************************************************************/
633: VOID vSetS3Bank(
634: PPDEV ppdev,
635: UINT iBank)
636: {
637:
638: TEST_928("S3.DLL!vSetS3Bank - pre bank switch 928 failure\n");
639:
640: // Set the bank
641:
642: OUTPW1 (CRTC_INDEX, (((ppdev->jS3R5 | (0x0F & iBank)) << 8) | S3R5));
643:
644: if (ppdev->bNewBankControl == TRUE)
645: {
646: OUTP1 (CRTC_INDEX, EX_SCTL_2);
647: OUTP1 (CRTC_DATA, ppdev->ExtSysCtl2 | ((0x30 & iBank) >> 2));
648: }
649:
650: // CHIPBUG.
651: // Anil said I should read this back.
652:
653: INP1(CRTC_DATA);
654:
655: TEST_928("S3.DLL!vSetS3Bank - post bank switch 928 failure\n");
656:
657: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.