tests/testbios.c

   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,&regs);
 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(&regs);
 350
 351    if(exec_function(&regs)!=0)break;
 352   }
 353 }