Rev 3 | Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
2 | pj | 1 | #include <ll/i386/hw-data.h> |
2 | #include <ll/i386/mem.h> |
||
3 | #include <ll/i386/string.h> |
||
4 | #include <ll/i386/x-dos.h> |
||
5 | #include <ll/i386/x-dosmem.h> |
||
6 | #include <ll/i386/cons.h> |
||
7 | #include <ll/sys/ll/ll-func.h> |
||
8 | |||
9 | #include "vesa.h" |
||
10 | #include "chips.h" |
||
11 | |||
12 | |||
13 | VbeInfoBlock VbeInfo; /* VBE 2.0 Informations */ |
||
14 | DWORD vbe_screen; /* Frame Linear Buffer Address */ |
||
15 | |||
16 | char VideoModeNames [96][40] = { |
||
17 | "100 - 640x400 256 colors", "101 - 640x480 256 colors", "102 - 800x600 16 colors", |
||
18 | "103 - 800x600 256 colors", "104 - 1024x768 16 colors", "105 - 1024x768 256 colors", |
||
19 | "106 - 1280x1024 16 colors", "107 - 1280x1024 256 colors", "108 - 80x60 Text Mode", |
||
20 | "109 - 132x25 Text Mode", "10A - 132x43 Text Mode", "10B - 132x50 Text Mode", |
||
21 | "10C - 132x60 Text Mode", "10D - 320x200 32,768 colors", "10E - 320x200 65,536 colors", |
||
22 | "10F - 320x200 16m colors", "110 - 640x480 32,768 colors", "111 - 640x480 65,536 colors", |
||
23 | "112 - 640x480 16m colors", "113 - 800x600 32,768 colors", "114 - 800x600 65,536 colors", |
||
24 | "115 - 800x600 16m colors", "116 - 1024x768 32,768 colors", "117 - 1024x768 65,536 colors", |
||
25 | "118 - 1024x768 16m colors", "119 - 1280x1024 32,768 colors", "11A - 1280x1024 65,536 colors", |
||
26 | "11B - 1280x1024 16m colors", "11C - 640x350 256 colors", "11D - 640x350 32,768 colors", |
||
27 | "11E - 640x400 32,768 colors", "11F - 640x350 65,536 colors", "120 - 640x400 65,536 colors", |
||
28 | "121 - 640x350 16m colors", "122 - 640x400 16m colors", "123 - 1600x1200 16 colors", |
||
29 | "124 - 1600x1200 256 colors", "125 - 1600x1200 32,768 colors", "126 - 1600x1200 65,536 colors", |
||
30 | "127 - 1600x1200 16m colors", "128 - 640x480 16m colors(*)", "129 - 800x600 16m colors(*)", |
||
31 | "12A - 1024x768 16m colors(*)", "12B - 1280x1024 16m colors(*)", "12C - 1600x1200 16m colors(*)", |
||
32 | "12D - 320x240 32,768 colors", "12E - 320x400 32,768 colors", "12F - 360x200 32,768 colors", |
||
33 | "130 - 360x240 32,768 colors", "131 - 360x400 32,768 colors", "132 - 320x240 65,536 colors", |
||
34 | "133 - 320x400 65,536 colors", "134 - 360x200 65,536 colors", "135 - 360x240 65,536 colors", |
||
35 | "136 - 360x400 65,536 colors", "137 - 320x240 16m colors", "138 - 320x400 16m colors", |
||
36 | "139 - name n/a", "13A - name n/a", "13B - name n/a", |
||
37 | "13C - name n/a", "13D - name n/a", "13E - name n/a", |
||
38 | "13F - name n/a", "140 - name n/a", "141 - name n/a", |
||
39 | "142 - 640x350 16m colors(*)", "143 - 640x400 16m colors(*)", "144 - name n/a", |
||
40 | "145 - name n/a", "146 - name n/a", "147 - name n/a", |
||
41 | "148 - name n/a", "149 - name n/a", "14A - name n/a", |
||
42 | "14B - name n/a", "14C - name n/a", "14D - name n/a", |
||
43 | "14E - name n/a", "14F - name n/a", "150 - 640x350 16 colors", |
||
44 | "151 - 640x400 16 colors", "152 - 640x480 16 colors", "153 - 320x200 256 colors", |
||
45 | "154 - 320x240 256 colors", "155 - 320x400 256 colors", "156 - 360x200 256 colors", |
||
46 | "157 - 360x240 256 colors", "158 - 360x400 256 colors", "159 - name n/a", |
||
47 | "15A - name n/a", "15B - name n/a", "15C - name n/a", |
||
48 | "15D - name n/a", "15E - name n/a", "15F - name n/a" |
||
49 | }; |
||
50 | |||
51 | int vbe_check_status (WORD vbe_function_result) |
||
52 | { |
||
53 | /* |
||
54 | if (vbe_function_result != 0x004f) { |
||
55 | cprintf("\nWarning! There was an error: (%x) ", vbe_function_result); |
||
56 | switch (vbe_function_result) { |
||
57 | case 0x014f : cprintf("generic."); break; |
||
58 | case 0x024f : cprintf("hardware incompatibility."); break; |
||
59 | case 0x034f : cprintf("unvalid function."); break; |
||
60 | default : cprintf("unknown error %x.\n", vbe_function_result); |
||
61 | } |
||
62 | */ |
||
63 | if (vbe_function_result != 0x004f) { |
||
64 | switch (vbe_function_result) { |
||
65 | case 0x014f : return -1; /* VBE Generic error */ |
||
66 | case 0x024f : return -2; /* Hardware incompatibility error */ |
||
67 | case 0x034f : return -3; /* Unvalid function requested */ |
||
68 | default : return -4; /* Unknown error */ |
||
69 | } |
||
70 | } |
||
71 | return 1; |
||
72 | } |
||
73 | |||
74 | int vbe_getinfo(void) |
||
75 | { |
||
76 | X_REGS16 inregs, outregs; /* registri normali */ |
||
77 | X_SREGS16 sregs; /* registri estesi */ |
||
78 | LIN_ADDR DOSaddr; |
||
79 | DWORD linearaddr; |
||
80 | #ifndef VM86 |
||
81 | BYTE p1, p2; |
||
82 | #endif |
||
83 | |||
84 | /* Allochiamo mem per il nostro blocco */ |
||
85 | if ((DOSaddr = DOS_alloc(sizeof(VbeInfoBlock))) == 0) { |
||
86 | /* set_text_mode ();*/ |
||
87 | return -1; |
||
88 | } else { |
||
89 | /* linearaddr = appl2linear(DOSaddr);*/ |
||
90 | linearaddr = (DWORD) DOSaddr; |
||
91 | |||
92 | /* 0x00 = Get Vbe2.0 Info */ |
||
93 | inregs.x.ax = 0x4f00; |
||
94 | /* Indirizzo reale del nostro blocco */ |
||
95 | inregs.x.di = linearaddr & 0x000F; |
||
96 | sregs.es = ((linearaddr & 0xFFFF0) >> 4); |
||
97 | sregs.ds = ((linearaddr & 0xFFFF0) >> 4); |
||
98 | |||
99 | /* Settiamo il VbeSignature correttamente */ |
||
100 | VbeInfo.VbeSignature[0] = 'V'; |
||
101 | VbeInfo.VbeSignature[1] = 'B'; |
||
102 | VbeInfo.VbeSignature[2] = 'E'; |
||
103 | VbeInfo.VbeSignature[3] = '2'; |
||
104 | |||
105 | memcpy((void *)linearaddr, &VbeInfo, sizeof(VbeInfo)); |
||
106 | #ifndef VM86 |
||
107 | p1 = inp(0x21); |
||
108 | p2 = inp(0xA1); |
||
109 | outp(0x21,0xFF); |
||
110 | outp(0xA1,0xFF); |
||
111 | X_callBIOS(0x10, &inregs, &outregs, &sregs); |
||
112 | outp(0x21,p1); |
||
113 | outp(0xA1,p2); |
||
114 | #else |
||
115 | vm86_callBIOS(0x10, &inregs, &outregs, &sregs); |
||
116 | #endif |
||
117 | if (vbe_check_status(outregs.x.ax) < 0) |
||
118 | return -1; |
||
119 | memcpy(&VbeInfo, (void *)linearaddr, sizeof(VbeInfo)); |
||
120 | return 1; |
||
121 | } |
||
122 | } |
||
123 | |||
124 | int vbe_check(char *key) |
||
125 | { |
||
126 | LIN_ADDR VendorNameaddr; |
||
127 | char VendorName[256]; |
||
128 | int i, k, len, found; |
||
129 | |||
130 | found = CHIP_NOT_FOUND; |
||
131 | VendorNameaddr = (void *)((VbeInfo.OemNameSegment<<4) + VbeInfo.OemNameOffset); |
||
132 | memcpy(VendorName, VendorNameaddr, 256); |
||
133 | |||
134 | len = strlen(key); |
||
135 | for (i = 0; i <= 512 - len; i++) { |
||
136 | if (VendorName[i] == key[0]) { |
||
137 | //cprintf("%c", VendorName[i]); |
||
138 | found = CHIP_FOUND; |
||
139 | for (k = 1; k < len; k++) { |
||
140 | if (VendorName[i + k] != key[k]) found = CHIP_NOT_FOUND; |
||
141 | } |
||
142 | if (found == CHIP_FOUND) return found; |
||
143 | } |
||
144 | } |
||
145 | return found; |
||
146 | } |
||
147 | |||
148 | int vbe_check_id(void) |
||
149 | { |
||
150 | if (vbe_check("Chips") == CHIP_FOUND) return CHIPS; |
||
151 | if (vbe_check("Cirrus") == CHIP_FOUND) return CIRRUS; |
||
152 | if (vbe_check("Diamond") == CHIP_FOUND) return DIAMOND; |
||
153 | if (vbe_check("ITT") == CHIP_FOUND) return ITT; |
||
154 | if (vbe_check("Western Digital") == CHIP_FOUND) return WD; |
||
155 | if (vbe_check("S3") == CHIP_FOUND) return S3; |
||
156 | if (vbe_check("Trident") == CHIP_FOUND) return TRIDENT; |
||
157 | if (vbe_check("Tseng") == CHIP_FOUND) return TSENG; |
||
158 | return UNKNOWN; |
||
159 | } |
||
160 | |||
161 | void vbe_showinfo(void) |
||
162 | { |
||
163 | char Name[256], VendorName[256], ProductName[256], ProductRev[256]; |
||
164 | LIN_ADDR Nameaddr, VendorNameaddr, ProductNameaddr, ProductRevaddr; |
||
165 | |||
166 | Nameaddr = (LIN_ADDR)((VbeInfo.OemNameSegment<<4) + VbeInfo.OemNameOffset); |
||
167 | memcpy(Name, Nameaddr, 256); |
||
168 | |||
169 | VendorNameaddr = (LIN_ADDR)((VbeInfo.OemVendorNameSegment<<4) + VbeInfo.OemVendorNameOffset); |
||
170 | memcpy(VendorName, VendorNameaddr, 256); |
||
171 | |||
172 | ProductNameaddr = (LIN_ADDR)((VbeInfo.OemProductNameSegment<<4) + VbeInfo.OemProductNameOffset); |
||
173 | memcpy(ProductName, ProductNameaddr, 256); |
||
174 | |||
175 | ProductRevaddr = (LIN_ADDR)((VbeInfo.OemProductRevSegment<<4) + VbeInfo.OemProductRevOffset); |
||
176 | memcpy(ProductRev, ProductRevaddr, 256); |
||
177 | |||
178 | cprintf ("\n"); |
||
179 | |||
180 | cprintf ("Software ................. %s\n", Name); |
||
181 | |||
182 | if (VendorNameaddr == 0) cprintf ("Vendor Name .............. n/a\n"); |
||
183 | else cprintf ("Vendor Name .............. %s\n", VendorName); |
||
184 | |||
185 | if (ProductNameaddr == 0) cprintf ("Product Name ............. n/a\n"); |
||
186 | else cprintf ("Product Name ............. %s\n", ProductName); |
||
187 | |||
188 | if (ProductRevaddr == 0) cprintf ("Product Revision ......... n/a\n"); |
||
189 | else cprintf ("Product Revision ......... %s\n", ProductRev); |
||
190 | |||
191 | cprintf ("--------------------------------------------------------\n"); |
||
192 | |||
193 | cprintf ("Driver Version............ %d.%d\n", VbeInfo.VbeVersion/100, |
||
194 | VbeInfo.VbeVersion%100); |
||
195 | |||
196 | cprintf ("Total Memory OnBoard...... %d Kb\n", VbeInfo.TotalMemory<<6); |
||
197 | |||
198 | cprintf ("Capabilities:\n"); |
||
199 | |||
200 | (VbeInfo.Capabilities[0]&1) ? cprintf (" - DAC is fixed width, with 6 bits per primary color\n") |
||
201 | : cprintf (" - DAC width is switchable to 8 bits per primary color\n"); |
||
202 | (VbeInfo.Capabilities[0]&2) ? cprintf (" - Controller is VGA compatible\n") |
||
203 | : cprintf (" - Controller is not VGA compatible\n"); |
||
204 | (VbeInfo.Capabilities[0]&3) ? cprintf (" - Normal RAMDAC operation\n") |
||
205 | : cprintf (" - RAMDAC recommends programming during blank period only\n"); |
||
206 | } |
||
207 | |||
208 | void vbe_showmodes(void) |
||
209 | { |
||
210 | short int modec; |
||
211 | WORD list; |
||
212 | LIN_ADDR VideoModeaddr; |
||
213 | |||
214 | list=0; |
||
215 | VideoModeaddr = (LIN_ADDR)((VbeInfo.SupportedModesSegment<<4) + VbeInfo.SupportedModesOffset); |
||
216 | |||
217 | cprintf ("\nList of modes supported:\n"); |
||
218 | do { |
||
219 | /*modec = (unsigned char) DOSPeek(VideoModePtr);*/ |
||
220 | memcpy(&modec, VideoModeaddr, 2); |
||
221 | VideoModeaddr += 2; |
||
222 | if (modec != -1) cprintf (" %s ", VideoModeNames[modec - 0x100]); |
||
223 | /* cprintf("%x/%d ", modec, (modec & 0xFF));*/ |
||
224 | list++; |
||
225 | if (list % 2 == 0) cprintf ("\n"); |
||
226 | } while ((modec != -1) && (list < 40)); |
||
227 | |||
228 | cprintf ("\nToal modes supported: %d", list); |
||
229 | } |
||
230 | |||
231 | DWORD vbe_getmodeinfo(ModeInfoBlock *ModeInfo, WORD Vbe_Mode) |
||
232 | { |
||
233 | X_REGS16 inregs, outregs; |
||
234 | X_SREGS16 sregs; |
||
235 | LIN_ADDR dosaddr; |
||
236 | #ifndef VM86 |
||
237 | BYTE p1, p2; |
||
238 | #endif |
||
239 | |||
240 | if ((dosaddr = DOS_alloc(sizeof(ModeInfoBlock))) == 0) { |
||
241 | /* set_text_mode ();*/ |
||
242 | return(-1); |
||
243 | } |
||
244 | /* linearaddr = far2linear(DOSaddr); */ |
||
245 | |||
246 | /* 0x01 = Get Vbe Mode Info */ |
||
247 | inregs.x.ax = 0x4f01; |
||
248 | inregs.x.cx = Vbe_Mode; |
||
249 | |||
250 | inregs.x.di = (DWORD)dosaddr & 0x000F; |
||
251 | sregs.es = (((DWORD)dosaddr & 0xFFFF0) >> 4); |
||
252 | sregs.ds = (((DWORD)dosaddr & 0xFFFF0) >> 4); |
||
253 | |||
254 | #ifndef VM86 |
||
255 | p1 = inp(0x21); |
||
256 | p2 = inp(0xA1); |
||
257 | outp(0x21,0xFF); |
||
258 | outp(0xA1,0xFF); |
||
259 | X_callBIOS(0x10, &inregs, &outregs, &sregs); |
||
260 | outp(0x21,p1); |
||
261 | outp(0xA1,p2); |
||
262 | #else |
||
263 | vm86_callBIOS(0x10, &inregs, &outregs, &sregs); |
||
264 | #endif |
||
265 | if (vbe_check_status (outregs.x.ax) < 0) { |
||
266 | return -1; |
||
267 | } |
||
268 | |||
269 | memcpy(ModeInfo, dosaddr, sizeof(ModeInfoBlock)); |
||
270 | |||
271 | vbe_screen = ModeInfo->PhysBasePtr; |
||
272 | if(vbe_screen == -1) { |
||
273 | return -1; |
||
274 | } |
||
275 | return vbe_screen; |
||
276 | } |
||
277 | |||
278 | DWORD vbe_getflb(void) |
||
279 | { |
||
280 | return vbe_screen; |
||
281 | } |
||
282 | |||
283 | int vbe_setmode (WORD Vbe_Mode) |
||
284 | { |
||
285 | X_REGS16 inregs, outregs; |
||
286 | X_SREGS16 sregs; |
||
287 | #ifndef VM86 |
||
288 | BYTE p1, p2; |
||
289 | #endif |
||
290 | |||
291 | /* Se volessimo il Linear Frame Buffer, dovremmo fare |
||
292 | Vbe_Mode = Vbe_Mode | 0x4000; |
||
293 | */ |
||
294 | memset (&inregs, 0, sizeof(inregs)); |
||
295 | /* Set Vesa Vbe mode */ |
||
296 | inregs.x.ax = 0x4f02; |
||
297 | inregs.x.bx = Vbe_Mode; |
||
298 | #ifndef VM86 |
||
299 | p1 = inp(0x21); |
||
300 | p2 = inp(0xA1); |
||
301 | outp(0x21,0xFF); |
||
302 | outp(0xA1,0xFF); |
||
303 | X_callBIOS(0x10, &inregs, &outregs, &sregs); |
||
304 | outp(0x21,p1); |
||
305 | outp(0xA1,p2); |
||
306 | #else |
||
307 | vm86_callBIOS(0x10, &inregs, &outregs, &sregs); |
||
308 | #endif |
||
309 | |||
310 | return vbe_check_status (outregs.x.ax); |
||
311 | } |
||
312 | |||
313 | WORD vbe_getbpr(ModeInfoBlock *ModeInfo) |
||
314 | { |
||
315 | return ModeInfo->BytesPerScanLine; |
||
316 | } |
||
317 | |||
318 | int vbe_setbank(ModeInfoBlock *ModeInfo, BYTE bank) |
||
319 | { |
||
320 | X_REGS16 inregs, outregs; |
||
321 | X_SREGS16 sregs; |
||
322 | #ifndef VM86 |
||
323 | BYTE p1, p2; |
||
324 | #endif |
||
325 | |||
326 | memset (&inregs, 0, sizeof(inregs)); |
||
327 | memset (&sregs, 0, sizeof(sregs)); |
||
328 | /* Set Window */ |
||
329 | inregs.x.ax = 0x4f05; |
||
330 | inregs.h.bh = 0x00; |
||
331 | inregs.h.bl = 0x00; |
||
332 | inregs.x.dx = (64 / ModeInfo->WinGranularity) * bank; |
||
333 | #ifndef VM86 |
||
334 | p1 = inp(0x21); |
||
335 | p2 = inp(0xA1); |
||
336 | outp(0x21,0xFF); |
||
337 | outp(0xA1,0xFF); |
||
338 | X_callBIOS(0x10, &inregs, &outregs, &sregs); |
||
339 | outp(0x21,p1); |
||
340 | outp(0xA1,p2); |
||
341 | #else |
||
342 | vm86_callBIOS(0x10, &inregs, &outregs, &sregs); |
||
343 | #endif |
||
344 | return vbe_check_status (outregs.x.ax); |
||
345 | } |
||
346 | |||
347 | void vbe_showmodeinfo (ModeInfoBlock *ModeInfo) |
||
348 | { |
||
349 | cprintf ("\n Mode: %dx%dx%d (%d bits)", ModeInfo->XResolution, |
||
350 | ModeInfo->YResolution, |
||
351 | ModeInfo->BitsPerPixel<<5, |
||
352 | ModeInfo->BitsPerPixel); |
||
353 | |||
354 | (ModeInfo->ModeAttributes&1)? cprintf ("\n - Mode SUPPORTED in hardware configuration") |
||
355 | : cprintf ("\n - Mode NOT supported in hardware configuration"); |
||
356 | (ModeInfo->ModeAttributes&5)? cprintf ("\n - Color Mode") |
||
357 | : cprintf ("\n - Text Mode"); |
||
358 | (ModeInfo->ModeAttributes&6)? cprintf ("\n - Not VGA compatible") |
||
359 | : cprintf ("\n - VGA compatible"); |
||
360 | (ModeInfo->ModeAttributes&7)? cprintf ("\n - Windowed memory mode available") |
||
361 | : cprintf ("\n - Windowed memory NOT mode available"); |
||
362 | (ModeInfo->ModeAttributes&8)? cprintf ("\n - Linear Frame Buffer available :-)") |
||
363 | : cprintf ("\n - Linear Frame Buffer NOT available :-("); |
||
364 | |||
365 | cprintf ("\n\n Bytes Per ScanLine %d", ModeInfo->BytesPerScanLine); |
||
366 | |||
367 | cprintf ("\n\n Window A Attributes:"); |
||
368 | (ModeInfo->WinAAttributes&1)? cprintf ("\n - Window is relocatable") |
||
369 | : cprintf ("\n - Window is not relocatable"); |
||
370 | (ModeInfo->WinAAttributes&2)? cprintf ("\n - Window is readable") |
||
371 | : cprintf ("\n - Window is not readable"); |
||
372 | (ModeInfo->WinAAttributes&3)? cprintf ("\n - Window is writeable") |
||
373 | : cprintf ("\n - Window is not writeable"); |
||
374 | |||
375 | /* Tolgo x leggere... |
||
376 | cprintf ("\n\n Window B Attributes:"); |
||
377 | (ModeInfo->WinBAttributes&1)? cprintf ("\n - Window is relocatable") |
||
378 | : cprintf ("\n - Window is not relocatable"); |
||
379 | (ModeInfo->WinBAttributes&2)? cprintf ("\n - Window is readable") |
||
380 | : cprintf ("\n - Window is not readable"); |
||
381 | (ModeInfo->WinBAttributes&3)? cprintf ("\n - Window is writeable") |
||
382 | : cprintf ("\n - Window is not writeable"); |
||
383 | */ |
||
384 | cprintf ("\n\n Window granularity %u Kb", ModeInfo->WinGranularity); |
||
385 | cprintf ("\n Window size %u Kb", ModeInfo->WinSize); |
||
386 | cprintf ("\n Segment: %x", ModeInfo->WinBSegment); |
||
387 | cprintf ("\n\n Memory Model is "); |
||
388 | switch (ModeInfo->MemoryModel) |
||
389 | { |
||
390 | case 0x00: cprintf ("Text Mode"); break; |
||
391 | case 0x01: cprintf ("CGA Graphics"); break; |
||
392 | case 0x02: cprintf ("Hercules Graphics"); break; |
||
393 | case 0x03: cprintf ("Planar"); break; |
||
394 | case 0x04: cprintf ("Packed Pixel"); break; |
||
395 | case 0x05: cprintf ("Non-chain 4, 256 color"); break; |
||
396 | case 0x06: cprintf ("Direct Color"); break; |
||
397 | case 0x07: cprintf ("YUV Color"); break; |
||
398 | default: cprintf ("to be defined by OEM"); |
||
399 | } |
||
400 | |||
401 | cprintf ("\n Number of Banks %u", ModeInfo->NumberOfBanks); |
||
402 | cprintf ("\n Bank Size %u Kb\n", ModeInfo->BankSize); |
||
403 | |||
404 | /* cprintf ("\n Red Mask Size %d (%d)", ModeInfo->RedMaskSize, ModeInfo->RedFieldPosition); |
||
405 | cprintf ("\n Green Mask Size %d (%d)", ModeInfo->GreenMaskSize, ModeInfo->GreenFieldPosition); |
||
406 | cprintf ("\n Blue Mask Size %d (%d)", ModeInfo->BlueMaskSize, ModeInfo->BlueFieldPosition); |
||
407 | |||
408 | cprintf ("\n\nColor Mode Info:"); |
||
409 | (ModeInfo->DirectColorModeInfo&1)? cprintf ("\n - Color ramp is programmable") |
||
410 | : cprintf ("\n - Color ramp is fixed"); |
||
411 | (ModeInfo->DirectColorModeInfo&2)? cprintf ("\n - Bits in Rsvd are usable") |
||
412 | : cprintf ("\n - Bits in Rsvd are reserved");*/ |
||
413 | } |
||
414 | |||
415 | int vbe_checkmode(WORD mode) |
||
416 | { |
||
417 | LIN_ADDR VideoModeaddr; |
||
418 | short int modec; |
||
419 | BYTE done; |
||
420 | |||
421 | done = 0; |
||
422 | VideoModeaddr = (LIN_ADDR)((VbeInfo.SupportedModesSegment<<4) + VbeInfo.SupportedModesOffset); |
||
423 | do { |
||
424 | memcpy(&modec, VideoModeaddr, 2); |
||
425 | VideoModeaddr += 2; |
||
426 | if ((modec != -1) && (modec == mode)) { |
||
427 | done = 1; |
||
428 | } |
||
429 | } while ((modec != -1) && (!done)); |
||
430 | if (done == 1) return 1; |
||
431 | return -1; |
||
432 | } |
||
433 | |||
434 | DWORD vbe_getmem(void) |
||
435 | { |
||
436 | return (VbeInfo.TotalMemory<<6) * 1024; |
||
437 | } |