![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to VGAConsole.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev / i386|
Return to VGAConsole.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / i386 |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1992 NeXT Computer, Inc. All rights reserved.
26: *
27: * VGAConsole.c - VGA Mode 0x12 console implementation.
28: *
29: *
30: * HISTORY
31: * 02 Feb 93 Peter Graffagnino
32: * Created from FBConsole.c
33: */
34:
35: //
36: // Notes:
37: // * Considerations for supporting other VGA modes:
38: // This code uses off screen memory for the save behind area. This
39: // permits the use of write mode 1 to save the data resulting in
40: // a flicker-free restore, and makes the coding somewhat simpler. Care
41: // should be taken that there is enough memory there in other modes,
42: // or allocated storage.
43: //
44: // Since mode 12 fits comfortably in 64K/plane, no bank switching is
45: // currently done in this code. Higher res modes will need this.
46: //
47: // * This module implements the console functionality required by the
48: // ConsoleSupport protocol.
49: // * To find things that need to be fixed, search for FIX, to find questions
50: // to be resolved, search for ASK, to find stuff that still needs to be
51: // done, search for TO DO.
52:
53: #import <sys/syslog.h>
54: #import <bsd/dev/i386/VGAConsole.h>
55: #import <bsd/dev/i386/VGAConsPriv.h>
56: #import <driverkit/i386/displayRegisters.h>
57: #import <architecture/ascii_codes.h>
58:
59: #define NIL (0)
60:
61: #if defined(NX_CURRENT_COMPILER_RELEASE) && (NX_CURRENT_COMPILER_RELEASE < 320)
62: #define SIREG "e"
63: #else
64: #define SIREG "S"
65: #endif
66:
67: /* Window margins */
68: #define BG_MARGIN 2 // pixels of background to leave as margin
69: #define FG_MARGIN 1 // pixels of foreground to leave as margin
70: #define TOTAL_MARGIN (BG_MARGIN + FG_MARGIN)
71:
72: #define SVGA_SAVE_BITS (2 * SVGA_ROWBYTES * SVGA_HEIGHT)
73:
74: /*
75: * Ansi sequence state.
76: */
77: typedef enum {
78: AS_NORMAL,
79: AS_ESCAPE,
80: AS_BRACKET,
81: AS_R
82: } ansi_state_t;
83:
84: #define ANSI_STACK_SIZE 3
85: #define ANSI_STACK_MAX 2
86:
87: typedef struct _t_VGARegisters {
88: unsigned char GC[VGA_NUM_GC_REGS];
89: unsigned char SEQ[VGA_NUM_SEQ_REGS];
90: } VGARegisters;
91:
92: typedef struct _t_Console {
93: ScreenMode window_type;
94:
95: IODisplayInfo display;
96:
97: //
98: // The remaining fields are window parameters. These are only
99: // meaningful for text-type windows (window_type == SCM_TEXT or
100: // SCM_ALERT).
101: //
102:
103: //
104: // Current window origin in pixels, relative to origin of screen.
105: //
106: int window_origin_x;
107: int window_origin_y;
108:
109: //
110: // Window size information, in pixels and in characters.
111: //
112: int chars_per_row;
113: int pixels_per_row;
114: int chars_per_column;
115: int pixels_per_column;
116:
117: //
118: // Cursor location, in characters. Origin is top
119: // left corner of window = {0,0}.
120: //
121: int curr_row; // in characters
122: int curr_column; // in characters
123:
124: //
125: // Misc. video parameters. The background and foreground fields
126: // are slightly dependent on the hardware implementation; they'll
127: // work as long as bits per pixel <= 32.
128: //
129: unsigned int baseground; // bits for base color
130: unsigned int background; // bits for background pixel
131: unsigned int foreground; // bits for foreground pixel
132: unsigned int dark_grey; // bits for dark grey
133: unsigned int light_grey; // bits for light grey
134: boolean_t has_title;
135:
136: //
137: // Storage for saved region under an alert panel.
138: //
139: unsigned char *saveBits;
140: int saveHeight;
141: int saveRowBytes;
142: int saveBytes;
143: unsigned char *saveLocation;
144: VGARegisters savedRegisters; // save for Restore
145: VGARegisters tempRegisters; // save between operations
146:
147: ansi_state_t ansi_state; // track ansi escape sequence state
148: u_char ansi_stack[ANSI_STACK_SIZE];
149: u_char *ansi_stack_p;
150:
151: boolean_t isSVGA; // use SVGA methods
152: } ConsoleRep, *ConsolePtr;
153:
154: #define PLANE_MASK 0x0F // By default, use all planes
155: #define PIXEL_MASK 0xFF // By default, all pixels
156: #define RW_MODE 0x00 // Default VGA read/write mode
157:
158: //
159: // BEGIN: Private utility routines
160: //
161:
162: static inline int isTextMode(ConsolePtr console)
163: {
164: return ((console->window_type == SCM_TEXT) ||
165: (console->window_type == SCM_ALERT));
166: }
167:
168: static void SwapForegroundAndBackground(ConsolePtr console)
169: {
170: int temp_color;
171:
172: temp_color = console->foreground;
173: console->foreground = console->background;
174: console->background = temp_color;
175: }
176:
177: static inline int rread(int port, int index)
178: {
179: outb(port, index);
180: return(inb(port + 1));
181: }
182:
183:
184: static inline void SaveVGARegs(VGARegisters *saved)
185: {
186: int i;
187:
188: for (i = 0; i < VGA_NUM_GC_REGS; i++)
189: saved->GC[i] = rread(VGA_GC_ADDR,i);
190: #if defined(SAVE_ALL_SEQ_REGS)
191: for (i = 0; i < VGA_NUM_SEQ_REGS; i++)
192: saved->SEQ[i] = rread(VGA_SEQ_ADDR,i);
193: #else /* defined(SAVE_ALL_SEQ_REGS) */
194: saved->SEQ[2] = rread(VGA_SEQ_ADDR,2);
195: #endif /* defined(SAVE_ALL_SEQ_REGS) */
196: }
197:
198: static inline void RestoreVGARegs(VGARegisters *saved)
199: {
200: int i;
201:
202: for (i = 0; i < VGA_NUM_GC_REGS; i++)
203: IOWriteRegister(VGA_GC_ADDR,i, saved->GC[i]);
204: #if defined(SAVE_ALL_SEQ_REGS)
205: for (i = 0; i < VGA_NUM_SEQ_REGS; i++)
206: IOWriteRegister(VGA_SEQ_ADDR,i, saved->SEQ[i]);
207: #else /* defined(SAVE_ALL_SEQ_REGS) */
208: IOWriteRegister(VGA_SEQ_ADDR, 2, saved->SEQ[2]);
209: #endif /* defined(SAVE_ALL_SEQ_REGS) */
210: }
211:
212: static void FlipCursor(ConsolePtr console)
213: // Description: Turn cursor on/off. This just inverts every pixel at the
214: // character at (curr_rown, curr_column).
215: {
216:
217: int y;
218: // Screen-relative pixel coordinates of bounds of current character.
219: int start_y = console->window_origin_y +
220: console->curr_row * CHAR_H;
221: int end_y = start_y + CHAR_H;
222: int start_x = console->window_origin_x +
223: console->curr_column * CHAR_W;
224: unsigned char *cp;
225: volatile char mask;
226:
227: IOWriteRegister(VGA_GC_ADDR, 7, 0x0f); /* enable cdc planes */
228: IOWriteRegister(VGA_GC_ADDR, 5, 0x08); /* set read mode 1 */
229: IOWriteRegister(VGA_GC_ADDR, 2, console->background); /* setup color compare */
230: cp = (unsigned char *)console->display.frameBuffer +
231: start_y*console->display.rowBytes + (start_x >> 3);
232: for (y=start_y; y < end_y; y++) {
233: mask = *cp;
234: IOWriteRegister(VGA_GC_ADDR, 0, console->background); /* set color */
235: IOWriteRegister(VGA_GC_ADDR, 8, ~mask); /* set pixel mask */
236: *cp = 0xff;
237: IOWriteRegister(VGA_GC_ADDR, 0, console->foreground); /* set color */
238: IOWriteRegister(VGA_GC_ADDR, 8, mask); /* set pixel mask */
239: mask = *cp;
240: *cp = 0xff;
241: cp += console->display.rowBytes;
242: }
243:
244: IOWriteRegister(VGA_GC_ADDR, 5, RW_MODE); /* set read mode 0 */
245: IOWriteRegister(VGA_GC_ADDR, 8, PIXEL_MASK); /* set pixel mask */
246:
247: }
248:
249: /*
250: * Bank switching is currently not supported.
251: */
252:
253: static inline char SVGASegmentForAddress(register void *addr)
254: {
255: #if NOTYET
256: register char segment;
257: register int offset;
258:
259: offset = ((int)addr) - ((int)SVGA_FRAMEBUFFER_ADDRESS);
260: segment = offset % SVGABANKBYTES;
261: return(segment);
262: #else NOTYET
263: return 0;
264: #endif NOTYET
265: }
266:
267: static inline void SVGASelectSegment(char segment)
268: {
269: #if NOTYET
270: outb(VGA_GCR_SEGS, segment << 4 | segment);
271: #endif NOTYET
272: }
273:
274: static inline void SVGASelectSegmentForAddressIfNecessary(
275: unsigned char *addr,
276: char *currentSegmentPtr
277: )
278: {
279: #if NOTYET
280: char segment;
281:
282: segment = SVGASegmentForAddress(addr);
283:
284: if (segment != *currentSegmentPtr) {
285: SVGASelectSegment(segment);
286: *currentSegmentPtr = segment;
287: }
288: #endif NOTYET
289: }
290:
291:
292: static unsigned char leftMaskArray[] =
293: {0xff, 0x7f, 0x3f, 0x1f, 0xf, 0x7, 0x3, 0x1};
294:
295: static unsigned char rightMaskArray[] =
296: {0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe};
297:
298:
299:
300: static void rect(ConsolePtr console, int x, int y, int w, int h, int c)
301: {
302: int first_byte, last_byte;
303: unsigned char lmask, rmask;
304: int k, midcnt;
305: int x2 = x + w;
306: volatile unsigned char *rowptr;
307: int rowBytes = console->display.rowBytes;
308:
309: IOWriteRegister(VGA_GC_ADDR, 0, c); /* set color */
310: outb(VGA_GC_ADDR, 8); /* point to pixel mask reg */
311: first_byte = x >> 3;
312: last_byte = x2 >> 3;
313: lmask = leftMaskArray[x & 7];
314: rmask = rightMaskArray[x2 & 7];
315:
316: rowptr = (unsigned char *)console->display.frameBuffer +
317: y*rowBytes + first_byte;
318:
319: midcnt = last_byte - first_byte - 1;
320: if (midcnt == -1) { /* i.e. first_word == last_word */
321: outb(VGA_GC_ADDR + 1, rmask & lmask);
322: for(; --h >= 0;rowptr += rowBytes) {
323: volatile char forceReadByte = *rowptr;
324: *rowptr = 0xff;
325: }
326: } else {
327: for(; --h >= 0; rowptr += rowBytes) {
328: volatile unsigned char *p = rowptr;
329: volatile char foo = *p;
330: outb(VGA_GC_ADDR + 1, lmask);
331: *p++ = 0xff;
332: outb(VGA_GC_ADDR + 1, 0xff);
333: for(k = midcnt; --k >= 0;)
334: *p++ = 0xff; // no need to latch data.
335: outb(VGA_GC_ADDR + 1, rmask);
336: foo = *p;
337: *p = 0xff;
338: }
339: }
340: outb(VGA_GC_ADDR + 1, PIXEL_MASK);
341:
342: }
343:
344:
345: static void ClearWindow(ConsolePtr console)
346: // Description: Set contents of entire current window to background.
347: // Preconditions:
348: // * Cursor is off on entry and will remain so on exit.
349: {
350: rect(console, console->window_origin_x, console->window_origin_y,
351: console->pixels_per_row, console->pixels_per_column,
352: console->background);
353: }
354:
355: static void WipeScreen(ConsolePtr console, const unsigned pixel)
356: // Description: Fill the screen with specific pixel value.
357: {
358: rect(console, 0, 0, console->display.totalWidth,
359: console->display.height, pixel);
360: }
361:
362: static void ClearToEOL(ConsolePtr console)
363: // Description: Clear to end of line (within window), including current pos.
364: // Preconditions:
365: // * Cursor is 'off' on entry and will remain so on exit.
366: {
367: unsigned pixel_count;
368: int starting_x; // window-relative 'x' coordinate
369: int y;
370:
371: starting_x = console->window_origin_x +
372: (console->curr_column * CHAR_W);
373: y = console->window_origin_y + (console->curr_row * CHAR_H);
374:
375: pixel_count = console->pixels_per_row -
376: (starting_x - console->window_origin_x);
377:
378: rect(console, starting_x, y, pixel_count, CHAR_H , console->background);
379:
380: }
381:
382: static void Erase(ConsolePtr console)
383: // Description: Erase current cursor location.
384: {
385: // Screen-relative pixel coordinates of bounds of current character.
386: int start_y = console->window_origin_y +
387: console->curr_row * CHAR_H;
388: int start_x = console->window_origin_x +
389: console->curr_column * CHAR_W;
390:
391: rect(console, start_x, start_y, CHAR_W, CHAR_H, console->background);
392: }
393:
394: #define ENCODEBASE ' '
395:
396: static void BltChar(ConsolePtr console, const char c)
397: // Description: Paint one character at (curr_column, curr_row).
398: {
399: unsigned char *glyphbase; // the glyph we're rendering
400: int x,y; // location of upper left corner of glyph
401: int source_y;
402: volatile int tmp;
403: unsigned char *cp;
404:
405: // Erase current contents of {curr_row, curr_column}.
406: Erase(console);
407:
408: // Skip non-printing characters.
409: if (c < ENCODEBASE) {
410: return;
411: }
412:
413: glyphbase = ohlfs12[c - ENCODEBASE];
414: x = console->window_origin_x + console->curr_column * CHAR_W;
415: y = console->window_origin_y + console->curr_row * CHAR_H;
416:
417: IOWriteRegister(VGA_GC_ADDR, 0, console->foreground);/* set color */
418: cp = (unsigned char *)console->display.frameBuffer +
419: y*console->display.rowBytes + (x >> 3);
420: outb(VGA_GC_ADDR, 8); /* point to pixel mask reg */
421:
422: for (source_y = CHAR_H; source_y != 0; source_y--) {
423: outb(VGA_GC_ADDR + 1, *glyphbase++);
424: tmp = *cp;
425: *cp = 0xff;
426: cp += console->display.rowBytes;
427: }
428: outb(VGA_GC_ADDR + 1, PIXEL_MASK); /* restore to default */
429:
430: console->curr_column++;
431: return;
432: }
433:
434: /*
435: * Use bytemove as opposed to memmove. 32bit bus cycles seem to confuse
436: * the VGA.
437: */
438: static inline void bytemove(char *dst, char *src, int cnt)
439: {
440: #if DONT_USE_ASM
441: while(cnt--)
442: *dst++ = *src++;
443: #else DONT_USE_ASM
444: asm("rep; movsb"
445: : /* no outputs */
446: : "&c" (cnt), "D" (dst), SIREG (src)
447: : "ecx", "esi", "edi");
448: #endif DONT_USE_ASM
449: }
450:
451: static void FBPutC(ConsolePtr console, char c)
452: // Write one character to screen. Cursor is 'on' on entry and exit.
453: {
454: int repeat;
455: int i;
456:
457: if (!isTextMode(console))
458: return;
459:
460: /*
461: * First deal with ANSI escape sequences.
462: * This is a very bizarre implementation, copied from the m68k
463: * version.
464: */
465: switch(console->ansi_state) {
466: case AS_NORMAL:
467: if(c == esc) {
468: console->ansi_state = AS_ESCAPE;
469: return;
470: }
471: else {
472: break; // continue
473: }
474:
475: case AS_ESCAPE:
476: switch(c) {
477: case '[':
478: console->ansi_state = AS_BRACKET;
479: return;
480: default:
481: console->ansi_state = AS_NORMAL;
482: break; // continue
483: }
484:
485: case AS_BRACKET:
486: if(c >= '0' && c <= '9') {
487: *console->ansi_stack_p =
488: *console->ansi_stack_p * 10 + (c - '0');
489: return;
490: }
491: else if (c == ';') {
492: if(console->ansi_stack_p <
493: &console->ansi_stack[ANSI_STACK_MAX]) {
494: console->ansi_stack_p++;
495: }
496: return;
497: }
498: else {
499: for(i=0; i<ANSI_STACK_SIZE; i++) {
500: if (console->ansi_stack[i] == 0) {
501: console->ansi_stack[i] = 1;
502: }
503: }
504: repeat = *console->ansi_stack_p;
505: FlipCursor(console); // cursor off
506: switch (c) {
507:
508: case 'A':
509: while (repeat--) {
510: if(console->curr_row) {
511: console->curr_row--;
512: }
513: }
514: break;
515:
516: case 'B':
517: while (repeat--) {
518: console->curr_row++;
519: }
520: break;
521:
522: case 'C': // non destructive space
523: while (repeat--) {
524: console->curr_column++;
525: }
526: break;
527:
528: case 'D': // not in termcap
529: while (repeat--) {
530: if(console->curr_column) {
531: console->curr_column--;
532: }
533: }
534: break;
535:
536: case 'E': // not in termcap
537: console->curr_column = 0;
538: while (repeat--) {
539: console->curr_row++;
540: }
541: break;
542:
543: case 'H': // should be home
544: case 'f': // not in termcap
545: console->curr_column =
546: *console->ansi_stack_p - 1;
547: console->ansi_stack_p--;
548: console->curr_row =
549: *console->ansi_stack_p - 1;
550: console->ansi_stack_p--;
551: break;
552:
553: case 'K':
554: ClearToEOL(console);
555: break;
556:
557: case 'm': /* FIXME */
558: console->ansi_stack_p--;
559: console->ansi_stack_p--;
560:
561: /* prevent washout */
562: if(console->background ==
563: console->foreground) {
564: console->background = VGA_WHITE;
565: console->foreground = VGA_BLACK;
566: }
567: break;
568: }
569: }
570: console->ansi_stack_p = &console->ansi_stack[1];
571: for(i=0; i<ANSI_STACK_SIZE; i++)
572: console->ansi_stack[i] = 0;
573: console->ansi_state = AS_NORMAL;
574: goto proceed;
575: case AS_R:
576: // FIXME
577: break;
578: }
579:
580: FlipCursor(console); // cursor off
581: switch(c) {
582: case '\r': // Carriage return
583: console->curr_column = 0;
584: break;
585:
586: case '\n': // line feed
587: console->curr_column = 0;
588: console->curr_row++;
589: break;
590:
591: case '\b': // backspace
592: if (console->curr_column == 0)
593: break;
594: console->curr_column--;
595: break;
596:
597: case '\t':
598: // tab. Erase all characters up to and including the
599: // next tab stop.
600: {
601: int col, num_cols;
602:
603: num_cols = TAB_SIZE - (console->curr_column % TAB_SIZE);
604: FlipCursor(console); // cursor on
605: for (col = 0; col<num_cols; col++) {
606: FBPutC(console, ' '); // cursor on at return
607: }
608: FlipCursor(console); // cursor off
609: break;
610: }
611:
612: case np: // aka ff, form feed
613: console->curr_row = console->curr_column = 0;
614: ClearWindow(console);
615: break;
616:
617: case del:
618: console->curr_column++;
619: break;
620:
621: default:
622: // Normal case.
623: BltChar(console, c);
624: break;
625: }
626:
627: // Cursor is off.
628: proceed:
629: if (console->curr_column >= console->chars_per_row) {
630: // End-of-line wrap.
631: console->curr_column = 0;
632: console->curr_row++;
633: }
634:
635: if (console->curr_row >= console->chars_per_column) {
636: //
637: // Screen scroll. Copy the whole window down in memory
638: // (pixels_per_row * CHAR_H) pixels, starting at
639: // the first character in row 1.
640: //
641: unsigned char *src;
642: unsigned char *dst;
643: int source_y;
644:
645: console->curr_row = console->chars_per_column - 1;
646:
647: /*
648: * for screen-to-screen scrolling in graphics mode, we use
649: * write mode 1, and pretend its a 1 bit display. We also
650: * exploit the fact the the scrolling area begins and ends
651: * on a 0 mod 8 pixel address.
652: */
653:
654: IOReadModifyWriteRegister(VGA_GC_ADDR, 5, ~0x3, 0x1); /* write mode 1 */
655: src = (unsigned char *)console->display.frameBuffer +
656: (console->window_origin_y + CHAR_H)*console->display.rowBytes +
657: (console->window_origin_x >> 3);
658: dst = src - CHAR_H*console->display.rowBytes;
659: for (source_y = CHAR_H; // top, row 1
660: source_y < console->pixels_per_column; // bottom
661: source_y++) {
662:
663: bytemove(dst, src, console->pixels_per_row>>3);
664: src += console->display.rowBytes;
665: dst += console->display.rowBytes;
666: }
667: IOReadModifyWriteRegister(VGA_GC_ADDR, 5, ~0x3, 0x0); // restore write mode
668:
669: console->curr_column = 0;
670: ClearToEOL(console);
671: }
672:
673: // Cursor back on.
674: FlipCursor(console);
675: }
676:
677: static void SetTitle(ConsolePtr console, const char *title)
678: // Description: Draw title bar if none exists, write specified title into it.
679: // Drawing a title bar involves snarfing up row 0 of the window
680: // and decreasing the usable size of the window by one row.
681: // Preconditions:
682: // * Cursor is 'on' on entry and will remain so on exit.
683: {
684: int saved_curr_row = console->curr_row;
685: int saved_curr_column = console->curr_column;
686: int saved_origin_y;
687: int title_len = strlen(title);
688: int pixel_num;
689:
690: if ((title_len == 0) || (title_len > console->chars_per_row)) {
691: IOLog("console: Illegal title length (%d)\n", title_len);
692: return;
693: }
694: FlipCursor(console); // old cursor off
695: if (console->has_title) {
696: // First grow window by two rows - this absorbs the existing
697: // title bar.
698: console->window_origin_y -= CHAR_H * 2;
699: console->chars_per_column += 2;
700: console->pixels_per_column += CHAR_H * 2;
701: saved_curr_row += 2;
702: }
703:
704: // Clear row 0, center new title in it.
705: console->curr_row = 0;
706: rect(console,
707: console->window_origin_x,
708: console->window_origin_y,
709: CHAR_W * console->chars_per_row,
710: CHAR_H * 2 - BG_MARGIN,
711: console->foreground);
712: saved_origin_y = console->window_origin_y;
713: console->window_origin_y += CHAR_H / 2;
714: console->curr_column = (console->chars_per_row - title_len) / 2;
715: FlipCursor(console); // new cursor on
716: SwapForegroundAndBackground(console);
717: while (*title) {
718: FBPutC(console, *title++);
719: }
720: SwapForegroundAndBackground(console);
721: FlipCursor(console); // new cursor off
722: console->window_origin_y = saved_origin_y;
723:
724: // Draw grey lines one pixel away from border of title bar.
725: // Origin is currently at first pixel in top line of title bar.
726:
727: rect(console, // inside top
728: console->window_origin_x - BG_MARGIN,
729: console->window_origin_y - BG_MARGIN,
730: console->pixels_per_row + (BG_MARGIN * 2),
731: BG_MARGIN,
732: console->light_grey);
733: rect(console, // inside bottom
734: console->window_origin_x - BG_MARGIN,
735: console->window_origin_y + CHAR_H * 2 - TOTAL_MARGIN - BG_MARGIN,
736: console->pixels_per_row + BG_MARGIN * 2,
737: BG_MARGIN,
738: console->dark_grey);
739: for (pixel_num = 0; pixel_num < BG_MARGIN; pixel_num++) {
740: rect(console, // left
741: console->window_origin_x - BG_MARGIN + pixel_num,
742: console->window_origin_y - BG_MARGIN + pixel_num,
743: 1,
744: CHAR_H * 2 - 1 - (pixel_num * 2),
745: console->light_grey);
746: }
747: for (pixel_num = 1; pixel_num <= BG_MARGIN; pixel_num++) {
748: rect(console, // right
749: console->window_origin_x + console->pixels_per_row + pixel_num - 1,
750: console->window_origin_y - pixel_num,
751: 1,
752: CHAR_H * 2 - 1 - (BG_MARGIN - pixel_num) * 2,
753: console->dark_grey);
754: }
755: rect(console, // outside bottom
756: console->window_origin_x - TOTAL_MARGIN,
757: console->window_origin_y + CHAR_H * 2 - FG_MARGIN - BG_MARGIN,
758: console->pixels_per_row + TOTAL_MARGIN * 2,
759: FG_MARGIN,
760: console->foreground);
761:
762: // Diminish window size by two rows.
763: console->window_origin_y += CHAR_H * 2;
764: console->chars_per_column -= 2;
765: console->pixels_per_column -= CHAR_H * 2;
766:
767:
768: // Restore old cursor. Careful, the y axis just changed...
769: console->curr_column = saved_curr_column;
770: if (saved_curr_row > 0) {
771: console->curr_row = saved_curr_row - 2;
772: }
773: else {
774: // New row 0 - clear it.
775: ClearToEOL(console);
776: }
777: FlipCursor(console); // old cursor on
778: console->has_title = TRUE;
779: }
780:
781: static void UpdateWindowChars(ConsolePtr console)
782: // Description: Calculate window size in characters. Used when either window
783: // size or font changes.
784: {
785: console->chars_per_row = console->pixels_per_row / CHAR_W;
786: console->chars_per_column =
787: console->pixels_per_column / CHAR_H;
788: }
789:
790:
791: static void InitWindow(ConsolePtr console,
792: int width,
793: int height,
794: const char *title,
795: boolean_t initWindow,
796: boolean_t saveUnder)
797: // Description: Initialize window parameters. If initWindow is TRUE, an empty
798: // window is drawn in the screen, else we assume that a window
799: // already exists. Screen and font parameters must be valid on
800: // entry.
801: {
802:
803: // Truncate specified size to integral mutliple of character size
804: // in both dimensions.
805: width /= CHAR_W; // now in chars
806: height /= CHAR_H;
807: width *= CHAR_W; // now in pixels
808: height *= CHAR_H;
809:
810: // Ensure there's enough room for a border.
811: if (width > (console->display.width - TOTAL_MARGIN * 2))
812: width = console->display.width - TOTAL_MARGIN * 2;
813: if (height > (console->display.height - TOTAL_MARGIN * 2))
814: height = console->display.height - TOTAL_MARGIN * 2;
815:
816: //
817: // Init console window variables. The window is centered in the
818: // screen, minus a pixel or two to guarantee double word alignment
819: // for the first pixel of a row (until further developments...when
820: // we do alert panels, we can enumerate some cases here...).
821: //
822: console->window_origin_x = (console->display.width - width) / 2;
823: console->window_origin_y = (console->display.height - height) / 2;
824: console->pixels_per_row = width;
825: console->pixels_per_column = height;
826: (unsigned)console->window_origin_x &= ~0x07;
827:
828: UpdateWindowChars(console);
829:
830: console->curr_column = 0;
831: console->has_title = FALSE;
832:
833: if (initWindow) {
834: // Before we start drawing anything, save under if needed
835: if (saveUnder) {
836: int i;
837: unsigned char *save, *sp;
838: /*
839: * in saveUnder mode, we take care to preserve the VGA
840: * state we'll mess with during console operations. This
841: * consists of the 9 graphics controller registers
842: * and 5 sequencer registers in the VGA.
843: * We already did this in Init().
844: */
845:
846: /*
847: * load a default set of registers for mode 12
848: */
849: for(i = 0; i < VGA_NUM_GC_REGS; i++)
850: IOWriteRegister(VGA_GC_ADDR,i, defaultGCRegisters[i]);
851:
852: if (console->isSVGA) {
853: char currentSegment = 0;
854:
855: SaveVGARegs(&console->tempRegisters);
856: /*
857: * for SVGA, we use read mode 0 and copy the data to
858: * a global array, not off-screen display memory as with VGA
859: * mode 0x12.
860: */
861: console->saveHeight = height + TOTAL_MARGIN * 2;
862: console->saveRowBytes = width/8 + ((TOTAL_MARGIN + 7) / 8) * 2;
863: console->saveBytes = console->saveHeight*console->saveRowBytes;
864: /* saveBits was allocated when we allocated the console */
865: save = console->saveBits;
866:
867: // Read mode 0
868: IOReadModifyWriteRegister(VGA_GC_ADDR, 5, ~0x8, 0x0);
869:
870: // Copy the window contents into the save under.
871:
872: // Plane 0.
873: IOReadModifyWriteRegister(VGA_GC_ADDR, 4, ~0x3, 0x0);
874:
875: sp = console->saveLocation =
876: (unsigned char *)console->display.frameBuffer +
877: (console->window_origin_y - TOTAL_MARGIN) *
878: console->display.rowBytes +
879: (console->window_origin_x>>3) - 1;
880: SVGASelectSegment(currentSegment);
881: for (i = console->saveHeight; i != 0; i--) {
882: SVGASelectSegmentForAddressIfNecessary(sp,
883: ¤tSegment);
884: bytemove(save, sp, console->saveRowBytes);
885: sp += console->display.rowBytes;
886: save += console->saveRowBytes;
887: }
888:
889: // Plane 1.
890: IOReadModifyWriteRegister(VGA_GC_ADDR, 4, ~0x3, 0x1);
891: sp = console->saveLocation =
892: (unsigned char *)console->display.frameBuffer +
893: (console->window_origin_y - TOTAL_MARGIN) *
894: console->display.rowBytes +
895: (console->window_origin_x>>3) - 1;
896: for (i = console->saveHeight; i != 0; i--) {
897: SVGASelectSegmentForAddressIfNecessary(sp,
898: ¤tSegment);
899: bytemove(save, sp, console->saveRowBytes);
900: sp += console->display.rowBytes;
901: save += console->saveRowBytes;
902: }
903: SVGASelectSegment(currentSegment = 0);
904: // restore wr. mode
905: IOReadModifyWriteRegister(VGA_GC_ADDR, 5, ~0x3, 0x0);
906:
907: RestoreVGARegs(&console->tempRegisters);
908: } else {
909: /*
910: * for vga, we use write mode 1 and copy the data to
911: * off-screen memory. We save and extra byte on either side
912: * of the popup.
913: */
914: console->saveHeight = height + TOTAL_MARGIN * 2;
915: console->saveRowBytes = width/8 + ((TOTAL_MARGIN + 7) / 8) * 2;
916: console->saveBytes = console->saveHeight*console->saveRowBytes;
917: save = console->saveBits;
918:
919: sp = console->saveLocation =
920: (unsigned char *)console->display.frameBuffer +
921: (console->window_origin_y - TOTAL_MARGIN) *
922: console->display.rowBytes +
923: (console->window_origin_x>>3) - 1;
924:
925: // Copy the window contents into the save under
926: IOReadModifyWriteRegister(VGA_GC_ADDR, 5, ~0x3, 0x1); /* write mode 1 */
927: for (i = console->saveHeight; i != 0; i--) {
928: bytemove(save, sp, console->saveRowBytes);
929: sp += console->display.rowBytes;
930: save += console->saveRowBytes;
931: }
932: IOReadModifyWriteRegister(VGA_GC_ADDR, 5, ~0x3, 0x0); /* restore wr. mode*/
933: }
934: }
935:
936: // New window - cursor at origin.
937: console->curr_row = 0;
938: console->has_title = FALSE;
939:
940: // Draw the border. The border goes outside of the specified
941: // window. Outside lines are black; inside lines are
942: // half-tone.
943:
944: rect(console, // outside top
945: console->window_origin_x - TOTAL_MARGIN,
946: console->window_origin_y - TOTAL_MARGIN,
947: width + TOTAL_MARGIN * 2,
948: FG_MARGIN,
949: console->foreground);
950: rect(console, // inside top
951: console->window_origin_x - BG_MARGIN,
952: console->window_origin_y - BG_MARGIN,
953: width + BG_MARGIN * 2,
954: BG_MARGIN,
955: console->background);
956: rect(console, // inside bottom
957: console->window_origin_x - BG_MARGIN,
958: console->window_origin_y + height,
959: width + BG_MARGIN * 2,
960: BG_MARGIN,
961: console->background);
962: rect(console, // outside bottom
963: console->window_origin_x - TOTAL_MARGIN,
964: console->window_origin_y + height + BG_MARGIN,
965: width + TOTAL_MARGIN * 2,
966: FG_MARGIN,
967: console->foreground);
968: rect(console, // outside left
969: console->window_origin_x - TOTAL_MARGIN,
970: console->window_origin_y - TOTAL_MARGIN,
971: FG_MARGIN,
972: height + TOTAL_MARGIN * 2,
973: console->foreground);
974: rect(console, // inside left
975: console->window_origin_x - BG_MARGIN,
976: console->window_origin_y - BG_MARGIN,
977: BG_MARGIN,
978: height + BG_MARGIN * 2,
979: console->background);
980: rect(console, // inside right
981: console->window_origin_x + width,
982: console->window_origin_y - BG_MARGIN,
983: BG_MARGIN,
984: height + BG_MARGIN * 2,
985: console->background);
986: rect(console, // outside right
987: console->window_origin_x + width + BG_MARGIN,
988: console->window_origin_y - TOTAL_MARGIN,
989: FG_MARGIN,
990: height + TOTAL_MARGIN * 2,
991: console->foreground);
992:
993: // Clear the contents of the window and draw a cursor.
994: ClearWindow(console);
995: FlipCursor(console); // cursor on
996: SetTitle(console, title);
997: }
998: else {
999: /* Leave current window contents, just updating title.
1000: * We'll do a newline to make sure we have room for
1001: * our font and proceed.Initial cursor will be at
1002: * lower left corner.
1003: */
1004: console->curr_row = console->chars_per_column - 1;
1005: SetTitle(console, title);
1006: FBPutC(console, '\n');
1007: }
1008: return;
1009: }
1010:
1011: //
1012: // END: Private utility routines
1013: //
1014:
1015: //
1016: // BEGIN: Implementation of IOConsoleInfo functions
1017: //
1018: static void Free(IOConsoleInfo *cso)
1019: // Description: Free a FB Console object
1020: {
1021: ConsolePtr console = (ConsolePtr)cso->priv;
1022: if (console->isSVGA)
1023: IOFree(console->saveBits, SVGA_SAVE_BITS);
1024: IOFree(console, sizeof(ConsoleRep));
1025: IOFree(cso, sizeof(IOConsoleInfo));
1026: }
1027:
1028: static void Init(
1029: IOConsoleInfo *cso,
1030: ScreenMode mode,
1031: boolean_t initScreen,
1032: boolean_t initWindow,
1033: const char *title)
1034: {
1035: ConsolePtr console = (ConsolePtr)cso->priv;
1036: int i;
1037:
1038:
1039: console->background = VGA_WHITE;
1040: console->light_grey = VGA_LTGRAY;
1041: console->dark_grey = VGA_DKGRAY;
1042: console->foreground = VGA_BLACK;
1043: console->baseground = console->dark_grey;
1044:
1045: console->ansi_state = AS_NORMAL;
1046: for(i=0; i<ANSI_STACK_SIZE; i++) {
1047: console->ansi_stack[i] = 0;
1048: }
1049: console->ansi_stack_p = &console->ansi_stack[1]; // FIXME - why not 0?
1050:
1051: // Save these for later in case we need them for Restore().
1052: SaveVGARegs(&console->savedRegisters);
1053:
1054: // In case the display is not in the mode we want...
1055: if ((mode == SCM_TEXT || mode == SCM_GRAPHIC) && initScreen)
1056: VGASetGraphicsMode();
1057:
1058: // Set up VGA registers the way we want them.
1059: // Enable all planes in mask register.
1060: IOWriteRegister(VGA_SEQ_ADDR, 2, PLANE_MASK);
1061: for(i = 0; i < VGA_NUM_GC_REGS; i++)
1062: IOWriteRegister(VGA_GC_ADDR,i, defaultGCRegisters[i]);
1063:
1064: console->window_type = mode;
1065:
1066: // Initialize the screen, if appropriate.
1067: if (initScreen && (console->window_type != SCM_ALERT)) {
1068: WipeScreen(console, console->baseground);
1069: }
1070:
1071: switch(console->window_type) {
1072: case SCM_TEXT:
1073: InitWindow(console, TEXT_WIN_WIDTH, TEXT_WIN_HEIGHT,
1074: title, initWindow, 0 /* Don't save under */);
1075: break;
1076: case SCM_ALERT:
1077: InitWindow(console, ALERT_WIN_WIDTH, ALERT_WIN_HEIGHT,
1078: title, initWindow, 1 /* Save under */);
1079: break;
1080: case SCM_GRAPHIC:
1081: /* do nothing */
1082: break;
1083: default:
1084: panic("VGAConsole/VGAInitConsole: can't init");
1085: }
1086: return;
1087: }
1088:
1089: static int Restore(IOConsoleInfo *cso)
1090: {
1091: ConsolePtr console = (ConsolePtr)cso->priv;
1092: unsigned char *save, *dp;
1093: int i;
1094:
1095: if (console->window_type != SCM_ALERT) {
1096: IOLog("VGAConsole: bogus restore, mode %d\n", console->window_type);
1097: return -1;
1098: }
1099:
1100: if (console->isSVGA) {
1101: char currentSegment;
1102:
1103: // Copy save under bits back onto screen
1104: save = console->saveBits;
1105:
1106: IOReadModifyWriteRegister(VGA_GC_ADDR, 5, ~0x3, 0x0); /* write mode 0 */
1107: IOWriteRegister(VGA_GC_ADDR, 1, 0x0); /* disable set/reset write */
1108: IOWriteRegister(VGA_GC_ADDR, 8, 0xff); /* set pixel mask */
1109:
1110: // Plane 0.
1111: IOWriteRegister(VGA_SEQ_ADDR, 2, 0x1); /* map mask for plane 0 */
1112: dp = console->saveLocation;
1113: SVGASelectSegment(currentSegment = 0);
1114: for (i = console->saveHeight; i != 0; i--) {
1115: SVGASelectSegmentForAddressIfNecessary(dp, ¤tSegment);
1116: bytemove(dp, save, console->saveRowBytes);
1117: dp += console->display.rowBytes;
1118: save += console->saveRowBytes;
1119: }
1120:
1121: // Plane 1.
1122: IOWriteRegister(VGA_SEQ_ADDR, 2, 0x2); /* map mask for plane 1 */
1123: dp = console->saveLocation;
1124: for (i = console->saveHeight; i != 0; i--) {
1125: SVGASelectSegmentForAddressIfNecessary(dp, ¤tSegment);
1126: bytemove(dp, save, console->saveRowBytes);
1127: dp += console->display.rowBytes;
1128: save += console->saveRowBytes;
1129: }
1130: SVGASelectSegment(currentSegment = 0);
1131:
1132: } else {
1133: // Copy save under bits back onto screen
1134: save = console->saveBits;
1135: dp = console->saveLocation;
1136: IOReadModifyWriteRegister(VGA_GC_ADDR, 5, ~0x3, 0x1); /* write mode 1 */
1137: for (i = console->saveHeight; i != 0; i--) {
1138: bytemove(dp, save, console->saveRowBytes);
1139: dp += console->display.rowBytes;
1140: save += console->saveRowBytes;
1141: }
1142: }
1143:
1144: RestoreVGARegs(&console->savedRegisters);
1145:
1146: console->window_type = SCM_UNINIT;
1147:
1148: return 0;
1149: }
1150:
1151:
1152: static void
1153: vga_write_bpp2packd32_to_bpp4planar(unsigned int *dst, unsigned short *fb)
1154: {
1155: unsigned int i, dstvalue;
1156: unsigned short fbvalue;
1157: unsigned char fblo, fbhi;
1158:
1159: IOWriteRegister(VGA_SEQ_ADDR, 2, 0x02); // select plane 1
1160:
1161: dstvalue = *dst;
1162: i = dstvalue & 0xAAAA;
1163:
1164: fblo = 0xff ^
1165: (char) (((i & 0x8000) >> 15) | ((i & 0x2000) >> 12) |
1166: ((i & 0x0800) >> 9) | ((i & 0x0200) >> 6) |
1167: ((i & 0x0080) >> 3) | ((i & 0x0020) ) |
1168: ((i & 0x0008) << 3) | ((i & 0x0002) << 6));
1169: i = (dstvalue >> 16) & 0xAAAA;
1170: fbhi = 0xff ^
1171: (char) (((i & 0x8000) >> 15) | ((i & 0x2000) >> 12) |
1172: ((i & 0x0800) >> 9) | ((i & 0x0200) >> 6) |
1173: ((i & 0x0080) >> 3) | ((i & 0x0020) ) |
1174: ((i & 0x0008) << 3) | ((i & 0x0002) << 6));
1175: fbvalue = (((unsigned short)fbhi) << 8) | fblo;
1176: *fb = fbvalue;
1177:
1178: IOWriteRegister(VGA_SEQ_ADDR, 2, 0x01); // select plane 0
1179:
1180: dstvalue = *dst;
1181: i = dstvalue & 0x5555;
1182: fblo = 0xff ^
1183: (char) (((i & 0x4000) >> 14) | ((i & 0x1000) >> 11) |
1184: ((i & 0x0400) >> 8) | ((i & 0x0100) >> 5) |
1185: ((i & 0x0040) >> 2) | ((i & 0x0010) << 1) |
1186: ((i & 0x0004) << 4) | ((i & 0x0001) << 7));
1187: i = (dstvalue >> 16) & 0x5555;
1188: fbhi = 0xff ^
1189: (char) (((i & 0x4000) >> 14) | ((i & 0x1000) >> 11) |
1190: ((i & 0x0400) >> 8) | ((i & 0x0100) >> 5) |
1191: ((i & 0x0040) >> 2) | ((i & 0x0010) << 1) |
1192: ((i & 0x0004) << 4) | ((i & 0x0001) << 7));
1193: fbvalue = (((unsigned short)fbhi) << 8) | fblo;
1194: *fb = fbvalue;
1195:
1196: // restore default plane mask
1197: IOWriteRegister(VGA_SEQ_ADDR, 2, PLANE_MASK);
1198: }
1199:
1200:
1201: // VGABlitRect blits a rect onto the VGA mode 0x12 screen.
1202: // No error checking is done. The screen must be in the proper video
1203: // mode, the data must be in 2 bit format, on a 4 pixel boundary, and
1204: // a multiple of 4 pixels wide. Anything other than 16 pixel boundaries
1205: // is padded with light gray. -sam
1206: static int VGABlitRect(
1207: IOConsoleInfo *cso,
1208: unsigned char *data,
1209: struct km_drawrect *rect
1210: )
1211: {
1212: ConsolePtr console = (ConsolePtr)cso->priv;
1213: int pixel; /* Starting pixel in screen */
1214: int i, x, y;
1215: unsigned char value;
1216: unsigned char *dst = (unsigned char *)console->display.frameBuffer;
1217: unsigned short *tfb;
1218: unsigned int final_value;
1219: int extraLeftBytes;
1220:
1221: pixel = rect->x + (rect->y * console->display.width);
1222:
1223: extraLeftBytes = (rect->x % 16) / 4;
1224: pixel -= extraLeftBytes * 4;
1225:
1226: dst += pixel / 8;
1227:
1228: for ( y = 0; y < rect->height; ++y )
1229: {
1230: int bitShift = 30;
1231: final_value = 0;
1232:
1233: tfb = (unsigned short *) dst;
1234: for ( x = 0; x < rect->width; )
1235: {
1236: if (x == 0)
1237: {
1238: for (i=0; i<extraLeftBytes; i++)
1239: {
1240: final_value = final_value << 8;
1241: final_value |= 0x55;
1242: bitShift -= 8;
1243: }
1244: }
1245:
1246: value = *data++;
1247:
1248: for ( i = 0; i < 8; i += 2 )
1249: {
1250: final_value |= (((value>>(6-i)) & 3) << (30-bitShift));
1251: bitShift -= 2;
1252: }
1253:
1254: x += 4;
1255:
1256: if (bitShift < 0 || x >= rect->width)
1257: {
1258: for (; bitShift >= 0; bitShift -= 2)
1259: final_value |= (0x01 << (30-bitShift));
1260: vga_write_bpp2packd32_to_bpp4planar(&final_value, tfb++);
1261: bitShift = 30;
1262: final_value = 0;
1263: }
1264:
1265: }
1266: dst += 80;
1267: }
1268:
1269: return(0);
1270: }
1271:
1272: /*
1273: * DrawRect assumes that the caller has copied in any data from user space,
1274: * so this function is safe to call directly during kernel shutdown.
1275: */
1276:
1277: static int DrawRect(IOConsoleInfo *cso, const struct km_drawrect *km_rect)
1278: {
1279: ConsolePtr console = (ConsolePtr)cso->priv;
1280: long size; // Size in bytes corresponding to a given 2bpp area
1281: struct km_drawrect *rect = (struct km_drawrect *) km_rect;
1282: int ret = 0;
1283:
1284: if (console->window_type != SCM_GRAPHIC) {
1285: return( -1 );
1286: }
1287:
1288: /* Sanity check */
1289: if ((rect->width > console->display.width) ||
1290: (rect->height) > console->display.height) {
1291: return( -1 );
1292: }
1293:
1294: rect->x &= ~3; // Trunc to 4 pixel bound
1295: rect->width = (rect->width) & ~3; // Round down for safety
1296:
1297: size = (rect->width >> 2) * rect->height; /* size in bytes. */
1298: if ( size <= 0 )
1299: return( -1 );
1300:
1301: IOWriteRegister(VGA_GC_ADDR, 1, 0x00);
1302: VGABlitRect(cso, rect->data.bits, rect);
1303: IOWriteRegister(VGA_GC_ADDR, 1, PLANE_MASK);
1304:
1305: return(ret);
1306: }
1307:
1308: static int EraseRect(IOConsoleInfo *cso, const struct km_drawrect *km_rect)
1309: {
1310: ConsolePtr console = (ConsolePtr)cso->priv;
1311: if (km_rect->x + km_rect->width > console->display.width ||
1312: km_rect->y + km_rect->height > console->display.height)
1313: return -1;
1314: rect(console, km_rect->x, km_rect->y,
1315: km_rect->width, km_rect->height, 3 - (km_rect->data.fill & 3));
1316: return 0;
1317: }
1318:
1319: static void PutC(IOConsoleInfo *cso, char c)
1320: // Write one character to screen. Cursor is 'on' on entry and exit.
1321: {
1322: FBPutC((ConsolePtr)cso->priv, c);
1323: }
1324:
1325: static void GetSize(IOConsoleInfo *cso, struct ConsoleSize *s)
1326: // Return the screen size in pixels.
1327: {
1328: ConsolePtr console = (ConsolePtr)cso->priv;
1329: s->cols = console->chars_per_row;
1330: s->rows = console->chars_per_column;
1331: s->pixel_width = console->display.width;
1332: s->pixel_height = console->display.height;
1333: }
1334: //
1335: // END: Implementation of IOConsoleInfo functions
1336: //
1337:
1338:
1339: //
1340: // BEGIN: Exported routines
1341: //
1342:
1343: IOConsoleInfo *_VGAAllocateConsole(IODisplayInfo *display, boolean_t isSVGA)
1344: {
1345: IOConsoleInfo *cso = (IOConsoleInfo *)IOMalloc(sizeof(IOConsoleInfo));
1346: ConsolePtr console = (ConsolePtr)IOMalloc(sizeof(ConsoleRep));
1347:
1348: if (cso == NIL)
1349: return NIL;
1350: cso->priv = console;
1351: if (cso->priv == NIL) {
1352: IOFree(cso, sizeof(IOConsoleInfo));
1353: return NIL;
1354: }
1355: cso->Free = Free;
1356: cso->Init = Init;
1357: cso->Restore = Restore;
1358: cso->DrawRect = DrawRect;
1359: cso->EraseRect = EraseRect;
1360: cso->PutC = PutC;
1361: cso->GetSize = GetSize;
1362: console->display = *display;
1363: console->isSVGA = isSVGA;
1364:
1365: // Fill in the rest of the display structure...
1366: if (isSVGA) {
1367: // Until the implementation of bank switching support is complete,
1368: // use only top LINESPERBANK lines and thus avoid bank switching.
1369: console->display.height = SVGA_LINESPERBANK;
1370: console->display.frameBuffer = (void *)FRAMEBUFFER_ADDRESS;
1371: console->display.totalWidth = SVGA_TOTALWIDTH;
1372: console->display.rowBytes = SVGA_ROWBYTES;
1373: console->saveBits = (unsigned char *)IOMalloc(SVGA_SAVE_BITS);
1374: if (console->saveBits == NIL) {
1375: IOFree(cso, sizeof(IOConsoleInfo));
1376: IOFree(console, sizeof(ConsoleRep));
1377: return NIL;
1378: }
1379: } else {
1380: console->display.frameBuffer = (void *)FRAMEBUFFER_ADDRESS;
1381: console->display.totalWidth = VGA_TOTALWIDTH;
1382: console->display.rowBytes = VGA_ROWBYTES;
1383: console->saveBits =
1384: (unsigned char *)console->display.frameBuffer +
1385: console->display.rowBytes * console->display.height;
1386: }
1387:
1388: console->window_type = SCM_UNINIT;
1389: return cso;
1390: }
1391:
1392: IOConsoleInfo *SVGAAllocateConsole(IODisplayInfo *display)
1393: {
1394: return _VGAAllocateConsole(display, TRUE);
1395: }
1396: IOConsoleInfo *VGAAllocateConsole(IODisplayInfo *display)
1397: {
1398: return _VGAAllocateConsole(display, FALSE);
1399: }
1400:
1401: //
1402: // END: Exported routines
1403: //
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.