![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to testbios.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / vgabios / tests|
Return to testbios.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / vgabios / tests |
1.1 root 1: /*
2: This is a little turbo C program that executes
3: several int10, and let you inspect the content
4: of the vgabios area
5:
6: It is used to test the behavior of the vgabios
7: */
8:
9: #include <stdio.h>
10: #include <dos.h>
11: #include <conio.h>
12:
13:
14: typedef unsigned char Bit8u;
15: typedef unsigned short Bit16u;
16:
17: typedef struct
18: {Bit8u initial;
19: Bit8u current;
20: Bit16u nbcols;
21: Bit16u regen;
22: Bit16u start;
23: Bit16u curpos[8];
24: Bit8u curtyp;
25: Bit8u curpage;
26: Bit16u crtc;
27: Bit16u msr;
28: Bit16u cgapal;
29: Bit8u nbrows;
30: Bit16u cheight;
31: Bit8u ctl;
32: Bit8u switches;
33: Bit8u modeset;
34: Bit8u dcc;
35: Bit16u vsseg;
36: Bit16u vsoffset;
37: } BIOSAREA;
38:
39: void int10ax0003(struct REGPACK *regs)
40: {
41: regs->r_ax=0x0003;
42: intr(0x10,regs);
43: }
44:
45: void int10ax02(struct REGPACK *regs)
46: {
47: regs->r_ax=0x0200;
48: regs->r_bx=0x0000;
49: regs->r_dx=0x1710;
50: intr(0x10,regs);
51: printf("We are now at 24/17");
52: }
53:
54: void int10ax03(struct REGPACK *regs)
55: {
56: regs->r_ax=0x0300;
57: regs->r_bx=0x0000;
58: intr(0x10,regs);
59: printf("\nCursor is ax%04x cx%04x dx%04x\n",regs->r_ax,regs->r_cx,regs->r_dx);
60: }
61:
62: void int10ax0501(struct REGPACK *regs)
63: {
64: regs->r_ax=0x0501;
65: intr(0x10,regs);
66: regs->r_ax=0x0e61;
67: regs->r_bx=0x0000;
68: intr(0x10,regs);
69: printf("We are now on page 2");
70: }
71:
72: void int10ax0602(struct REGPACK *regs)
73: {
74: regs->r_ax=0x0602;
75: regs->r_bx=0x0700;
76: regs->r_cx=0x0101;
77: regs->r_dx=0x0a0a;
78: intr(0x10,regs);
79: printf("Scrolled 2 up");
80: }
81:
82: void int10ax0702(struct REGPACK *regs)
83: {
84: regs->r_ax=0x0702;
85: regs->r_bx=0x0700;
86: regs->r_cx=0x0101;
87: regs->r_dx=0x0a0a;
88: intr(0x10,regs);
89: printf("Scrolled 2 down");
90: }
91:
92: void int10ax08(struct REGPACK *regs)
93: {
94: regs->r_ax=0x0800;
95: regs->r_bx=0x0000;
96: intr(0x10,regs);
97: }
98:
99: void int10ax09(struct REGPACK *regs)
100: {
101: char attr;
102: regs->r_ax=0x0501;
103: intr(0x10,regs);
104: for(attr=0;attr<16;attr++)
105: {printf("%02x ",attr);
106: regs->r_ax=0x0961+attr;
107: regs->r_bx=0x0100+attr;
108: regs->r_cx=0x0016;
109: intr(0x10,regs);
110: printf("\n");
111: }
112: }
113:
114: void int10ax0a(struct REGPACK *regs)
115: {
116: regs->r_ax=0x0501;
117: intr(0x10,regs);
118: regs->r_ax=0x0a62;
119: regs->r_bx=0x0101;
120: regs->r_cx=0x0016;
121: intr(0x10,regs);
122: }
123:
124: void int10ax0f(struct REGPACK *regs)
125: {
126: regs->r_ax=0x0501;
127: intr(0x10,regs);
128: regs->r_ax=0x0f00;
129: intr(0x10,regs);
130: }
131:
132: void int10ax1b(struct REGPACK *regs)
133: {unsigned char table[64];
134: unsigned char far *ptable;
135: int i;
136:
137: regs->r_ax=0x0501;
138: intr(0x10,regs);
139: regs->r_ax=0x1b00;
140: regs->r_bx=0x0000;
141: ptable=&table;
142: regs->r_es=FP_SEG(ptable);
143: regs->r_di=FP_OFF(ptable);
144: printf("Read state info in %04x:%04x\n",regs->r_es,regs->r_di);
145: intr(0x10,regs);
146:
147: for(i=0;i<64;i++)
148: {if(i%16==0)printf("\n%02x ",i);
149: printf("%02x ",table[i]);
150: }
151: printf("\n");
152: }
153:
154: static unsigned char var[64];
155:
156: void int10ax13(struct REGPACK *regs)
157: {unsigned char far *pvar;
158:
159: pvar=&var;
160:
161: regs->r_ax=0x1300;
162: regs->r_bx=0x000b;
163: regs->r_dx=0x1010;
164: regs->r_cx=0x0002;
165: regs->r_es=FP_SEG(pvar);
166: regs->r_bp=FP_OFF(pvar);
167: pokeb(regs->r_es,regs->r_bp,'t');
168: pokeb(regs->r_es,regs->r_bp+1,'b');
169: printf("Writing from %04x:%04x\n",regs->r_es,regs->r_bp);
170: intr(0x10,regs);
171:
172: }
173:
174: void switch_50(struct REGPACK *regs)
175: {
176: regs->r_ax=0x1202;
177: regs->r_bx=0x3000;
178: intr(0x10,regs);
179: regs->r_ax=0x0003;
180: intr(0x10,regs);
181: regs->r_ax=0x1112;
182: regs->r_bx=0x0000;
183: intr(0x10,regs);
184: }
185:
186: char exec_function(struct REGPACK *regs)
187: {char c;
188:
189: printf("--- Functions --------------------\n");
190: printf("a. int10 ax0003\t");
191: printf("b. int10 ax02\t");
192: printf("c. int10 ax03\t");
193: printf("d. int10 ax0501\n");
194: printf("e. int10 ax0602\t");
195: printf("f. int10 ax0702\t");
196: printf("g. int10 ax08\t");
197: printf("h. int10 ax09\t");
198: printf("i. int10 ax0a\n");
199: printf("j. int10 ax0f\t");
200: printf("k. int10 ax1b\t");
201: printf("l. int10 ax13\n");
202: printf("q. Quit\t");
203: printf("r. switch to 50 lines\n");
204: c=getche();
205:
206: switch(c)
207: {case 'a':
208: int10ax0003(regs);
209: break;
210: case 'b':
211: int10ax02(regs);
212: break;
213: case 'c':
214: int10ax03(regs);
215: break;
216: case 'd':
217: int10ax0501(regs);
218: break;
219: case 'e':
220: int10ax0602(regs);
221: break;
222: case 'f':
223: int10ax0702(regs);
224: break;
225: case 'g':
226: int10ax08(regs);
227: break;
228: case 'h':
229: int10ax09(regs);
230: break;
231: case 'i':
232: int10ax0a(regs);
233: break;
234: case 'j':
235: int10ax0f(regs);
236: break;
237: case 'k':
238: int10ax1b(regs);
239: break;
240: case 'l':
241: int10ax13(regs);
242: break;
243: case 'q':
244: break;
245: case 'r':
246: switch_50(regs);
247: break;
248: default:
249: printf("No such function!\n");
250: }
251:
252: if(c=='q')return 1;
253: while(kbhit()==0);
254: c=getch();
255:
256: return 0;
257: }
258:
259: void read_bios_area(BIOSAREA *biosarea)
260: {
261: biosarea->initial=peekb(0x40,0x10);
262: biosarea->current=peekb(0x40,0x49);
263: biosarea->nbcols=peek(0x40,0x4a);
264: biosarea->regen=peek(0x40,0x4c);
265: biosarea->start=peek(0x40,0x4e);
266: biosarea->curpos[0]=peek(0x40,0x50);
267: biosarea->curpos[1]=peek(0x40,0x52);
268: biosarea->curpos[2]=peek(0x40,0x54);
269: biosarea->curpos[3]=peek(0x40,0x56);
270: biosarea->curpos[4]=peek(0x40,0x58);
271: biosarea->curpos[5]=peek(0x40,0x5a);
272: biosarea->curpos[6]=peek(0x40,0x5c);
273: biosarea->curpos[7]=peek(0x40,0x5e);
274: biosarea->curtyp=peek(0x40,0x60);
275: biosarea->curpage=peekb(0x40,0x62);
276: biosarea->crtc=peek(0x40,0x63);
277: biosarea->msr=peekb(0x40,0x65);
278: biosarea->cgapal=peekb(0x40,0x66);
279: biosarea->nbrows=peekb(0x40,0x84);
280: biosarea->cheight=peek(0x40,0x85);
281: biosarea->ctl=peekb(0x40,0x87);
282: biosarea->switches=peekb(0x40,0x88);
283: biosarea->modeset=peekb(0x40,0x89);
284: biosarea->dcc=peekb(0x40,0x8a);
285: biosarea->vsseg=peek(0x40,0xa8);
286: biosarea->vsoffset=peek(0x40,0xaa);
287: }
288:
289: void show_bios_area(BIOSAREA *biosarea)
290: {
291: printf("--- BIOS area --------------------\n");
292: printf("initial : %02x\t",biosarea->initial);
293: printf("current : %02x\t",biosarea->current);
294: printf("nbcols : %04x\t",biosarea->nbcols);
295: printf("regen : %04x\t",biosarea->regen);
296: printf("start : %04x\n",biosarea->start);
297: printf("curpos : %04x %04x %04x %04x %04x %04x %04x %04x\n",
298: biosarea->curpos[0], biosarea->curpos[1], biosarea->curpos[2], biosarea->curpos[3],
299: biosarea->curpos[4], biosarea->curpos[5], biosarea->curpos[6], biosarea->curpos[7]);
300: printf("curtyp : %04x\t",biosarea->curtyp);
301: printf("curpage : %02x\t",biosarea->curpage);
302: printf("crtc : %04x\t",biosarea->crtc);
303: printf("msr : %04x\n",biosarea->msr);
304: printf("cgapal : %04x\t",biosarea->cgapal);
305: printf("nbrows-1: %02x\t",biosarea->nbrows);
306: printf("cheight : %04x\t",biosarea->cheight);
307: printf("ctl : %02x\n",biosarea->ctl);
308: printf("switches: %02x\t",biosarea->switches);
309: printf("modeset : %02x\t",biosarea->modeset);
310: printf("dcc : %02x\t",biosarea->dcc);
311: printf("vs : %04x:%04x\n",biosarea->vsseg,biosarea->vsoffset);
312: }
313:
314: void show_regs(struct REGPACK *regs)
315: {
316: printf("--- Registers --------------------\n");
317: printf("ax %04x\t",regs->r_ax);
318: printf("bx %04x\t",regs->r_bx);
319: printf("cx %04x\t",regs->r_cx);
320: printf("dx %04x\t",regs->r_dx);
321: printf("ds %04x\t",regs->r_ds);
322: printf("si %04x\t",regs->r_si);
323: printf("es %04x\t",regs->r_es);
324: printf("di %04x\n",regs->r_di);
325: }
326:
327: void reset_videomode()
328: {
329: struct REGPACK regs;
330:
331: regs.r_ax=0x0003;
332: intr(0x10,®s);
333: }
334:
335: void main()
336: {
337:
338: BIOSAREA biosarea;
339: struct REGPACK regs;
340:
341: directvideo=0;
342:
343: while(1)
344: {
345: read_bios_area(&biosarea);
346:
347: reset_videomode();
348: show_bios_area(&biosarea);
349: show_regs(®s);
350:
351: if(exec_function(®s)!=0)break;
352: }
353: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.