git.mutantstargoat.com Git - eradicate/blob - src/dos/vbe.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <stddef.h>
   4 #include <assert.h>
   5 #include "vbe.h"
   6 #include "cdpmi.h"
   7
   8
   9 #define FIXPTR(ptr) \
  10         do { \
  11                 uint32_t paddr = (uint32_t)(ptr); \
  12                 uint16_t pseg = paddr >> 16; \
  13                 uint16_t poffs = paddr & 0xffff; \
  14                 if(pseg == seg && poffs < 512) { \
  15                         paddr = ((uint32_t)seg << 4) + poffs; \
  16                 } else { \
  17                         paddr = ((uint32_t)pseg << 4) + poffs; \
  18                 } \
  19                 (ptr) = (void*)phys_to_virt(paddr); \
  20         } while(0)
  21
  22 /* hijack the "VESA" sig field, to pre-cache number of modes */
  23 #define NMODES(inf) *(uint16_t*)((inf)->sig)
  24 #define NACCMODES(inf) *(uint16_t*)((inf)->sig + 2)
  25
  26 static int cur_pitch;
  27 /* TODO update cur_pitch on mode-change and on setscanlen */
  28
  29
  30 int vbe_info(struct vbe_info *info)
  31 {
  32         int i, num;
  33         void *lowbuf;
  34         uint16_t seg, sel;
  35         uint16_t *modeptr;
  36         struct dpmi_regs regs = {0};
  37
  38         assert(sizeof *info == 512);
  39
  40         if(!(seg = dpmi_alloc(sizeof *info / 16, &sel))) {
  41                 return -1;
  42         }
  43         lowbuf = (void*)phys_to_virt((uint32_t)seg << 4);
  44
  45         memcpy(lowbuf, "VBE2", 4);
  46
  47         regs.eax = 0x4f00;
  48         regs.es = seg;
  49         regs.edi = 0;
  50         dpmi_int(0x10, &regs);
  51
  52         if((regs.eax & 0xffff) != 0x4f) {
  53                 fprintf(stderr, "vbe_get_info (4f00) failed\n");
  54                 dpmi_free(sel);
  55                 return -1;
  56         }
  57
  58         memcpy(info, lowbuf, sizeof *info);
  59         dpmi_free(sel);
  60
  61         FIXPTR(info->oem_name);
  62         FIXPTR(info->vendor);
  63         FIXPTR(info->product);
  64         FIXPTR(info->revstr);
  65         FIXPTR(info->modes);
  66         FIXPTR(info->accel_modes);
  67
  68         modeptr = info->modes;
  69         while(*modeptr != 0xffff) {
  70                 if(modeptr - info->modes >= 256) {
  71                         modeptr = info->modes;
  72                         break;
  73                 }
  74                 modeptr++;
  75         }
  76         NMODES(info) = modeptr - info->modes;
  77
  78         if(info->caps & VBE_ACCEL) {
  79                 modeptr = info->accel_modes;
  80                 while(*modeptr != 0xffff) {
  81                         if(modeptr - info->accel_modes >= 256) {
  82                                 modeptr = info->accel_modes;
  83                                 break;
  84                         }
  85                         modeptr++;
  86                 }
  87                 NACCMODES(info) = modeptr - info->accel_modes;
  88         }
  89         return 0;
  90 }
  91
  92 int vbe_num_modes(struct vbe_info *info)
  93 {
  94         return NMODES(info);
  95 }
  96
  97 int vbe_mode_info(int mode, struct vbe_mode_info *minf)
  98 {
  99         int i, num;
 100         void *lowbuf;
 101         uint16_t seg, sel;
 102         struct dpmi_regs regs = {0};
 103
 104         assert(sizeof *minf == 256);
 105         assert(offsetof(struct vbe_mode_info, max_pixel_clock) == 0x3e);
 106
 107         if(!(seg = dpmi_alloc(sizeof *minf / 16, &sel))) {
 108                 return -1;
 109         }
 110         lowbuf = (void*)phys_to_virt((uint32_t)seg << 4);
 111
 112         regs.eax = 0x4f01;
 113         regs.ecx = mode;
 114         regs.es = seg;
 115         dpmi_int(0x10, &regs);
 116
 117         if((regs.eax & 0xffff) != 0x4f) {
 118                 fprintf(stderr, "vbe_mode_info (4f01) failed\n");
 119                 dpmi_free(sel);
 120                 return -1;
 121         }
 122
 123         memcpy(minf, lowbuf, sizeof *minf);
 124         dpmi_free(sel);
 125         return 0;
 126 }
 127
 128 void vbe_print_info(FILE *fp, struct vbe_info *vinf)
 129 {
 130         fprintf(fp, "vbe version: %u.%u\n", VBE_VER_MAJOR(vinf->ver), VBE_VER_MINOR(vinf->ver));
 131         if(VBE_VER_MAJOR(vinf->ver) >= 2) {
 132                 fprintf(fp, "%s - %s (%s)\n", vinf->vendor, vinf->product, vinf->revstr);
 133                 if(vinf->caps & VBE_ACCEL) {
 134                         fprintf(fp, "vbe/af %d.%d\n", VBE_VER_MAJOR(vinf->accel_ver), VBE_VER_MINOR(vinf->accel_ver));
 135                 }
 136         } else {
 137                 fprintf(fp, "oem: %s\n", vinf->oem_name);
 138         }
 139         fprintf(fp, "video memory: %dkb\n", vinf->vmem_blk * 64);
 140
 141         if(vinf->caps) {
 142                 fprintf(fp, "caps:");
 143                 if(vinf->caps & VBE_8BIT_DAC) fprintf(fp, " dac8");
 144                 if(vinf->caps & VBE_NON_VGA) fprintf(fp, " non-vga");
 145                 if(vinf->caps & VBE_DAC_BLANK) fprintf(fp, " dac-blank");
 146                 if(vinf->caps & VBE_ACCEL) fprintf(fp, " af");
 147                 if(vinf->caps & VBE_MUSTLOCK) fprintf(fp, " af-lock");
 148                 if(vinf->caps & VBE_HWCURSOR) fprintf(fp, " af-curs");
 149                 if(vinf->caps & VBE_HWCLIP) fprintf(fp, " af-clip");
 150                 if(vinf->caps & VBE_TRANSP_BLT) fprintf(fp, " af-tblt");
 151                 fprintf(fp, "\n");
 152         }
 153
 154         fprintf(fp, "%d video modes available\n", NMODES(vinf));
 155         if(vinf->caps & VBE_ACCEL) {
 156                 fprintf(fp, "%d accelerated (VBE/AF) modes available\n", NACCMODES(vinf));
 157         }
 158         fflush(fp);
 159 }
 160
 161 void vbe_print_mode_info(FILE *fp, struct vbe_mode_info *minf)
 162 {
 163         fprintf(fp, "%dx%d %dbpp", minf->xres, minf->yres, minf->bpp);
 164
 165         switch(minf->mem_model) {
 166         case VBE_TYPE_DIRECT:
 167                 fprintf(fp, " (rgb");
 168                 if(0) {
 169         case VBE_TYPE_YUV:
 170                         fprintf(fp, " (yuv");
 171                 }
 172                 fprintf(fp, " %d%d%d)", minf->rsize, minf->gsize, minf->bsize);
 173                 break;
 174         case VBE_TYPE_PLANAR:
 175                 fprintf(fp, " (%d planes)", minf->num_planes);
 176                 break;
 177         case VBE_TYPE_PACKED:
 178                 fprintf(fp, " (packed)");
 179                 break;
 180         case VBE_TYPE_TEXT:
 181                 fprintf(fp, " (%dx%d cells)", minf->xcharsz, minf->ycharsz);
 182                 break;
 183         case VBE_TYPE_CGA:
 184                 fprintf(fp, " (CGA)");
 185                 break;
 186         case VBE_TYPE_UNCHAIN:
 187                 fprintf(fp, " (unchained-%d)", minf->num_planes);
 188                 break;
 189         }
 190         fprintf(fp, " %dpg", minf->num_img_pages);
 191
 192         if(minf->attr & VBE_ATTR_LFB) {
 193                 fprintf(fp, " lfb@%lx", (unsigned long)minf->fb_addr);
 194         } else {
 195                 fprintf(fp, " %xkb/bank", (unsigned int)minf->bank_size);
 196         }
 197
 198         fprintf(fp, " [");
 199         if(minf->attr & VBE_ATTR_AVAIL) fprintf(fp, " avail");
 200         if(minf->attr & VBE_ATTR_OPTINFO) fprintf(fp, " opt");
 201         if(minf->attr & VBE_ATTR_TTY) fprintf(fp, " tty");
 202         if(minf->attr & VBE_ATTR_COLOR) fprintf(fp, " color");
 203         if(minf->attr & VBE_ATTR_GFX) fprintf(fp, " gfx");
 204         if(minf->attr & VBE_ATTR_NOTVGA) fprintf(fp, " non-vga");
 205         if(minf->attr & VBE_ATTR_BANKED) fprintf(fp, " banked");
 206         if(minf->attr & VBE_ATTR_LFB) fprintf(fp, " lfb");
 207         if(minf->attr & VBE_ATTR_DBLSCAN) fprintf(fp, " dblscan");
 208         if(minf->attr & VBE_ATTR_ILACE) fprintf(fp, " ilace");
 209         if(minf->attr & VBE_ATTR_TRIPLEBUF) fprintf(fp, " trplbuf");
 210         if(minf->attr & VBE_ATTR_STEREO) fprintf(fp, " stereo");
 211         if(minf->attr & VBE_ATTR_STEREO_2FB) fprintf(fp, " stdual");
 212         fprintf(fp, " ]\n");
 213         fflush(fp);
 214 }
 215
 216 int vbe_setmode(uint16_t mode)
 217 {
 218         struct dpmi_regs regs = {0};
 219
 220         regs.eax = 0x4f02;
 221         regs.ebx = mode;
 222         dpmi_int(0x10, &regs);
 223
 224         if((regs.eax & 0xffff) != 0x4f) {
 225                 return -1;
 226         }
 227
 228         cur_pitch = vbe_getpitch();
 229         return 0;
 230 }
 231
 232 int vbe_setmode_crtc(uint16_t mode, struct vbe_crtc_info *crtc)
 233 {
 234         void *lowbuf;
 235         uint16_t seg, sel;
 236         struct dpmi_regs regs = {0};
 237
 238         assert(sizeof *crtc == 59);
 239
 240         if(!(seg = dpmi_alloc((sizeof *crtc + 15) / 16, &sel))) {
 241                 return -1;
 242         }
 243         lowbuf = (void*)phys_to_virt((uint32_t)seg << 4);
 244
 245         memcpy(lowbuf, crtc, sizeof *crtc);
 246
 247         regs.eax = 0x4f02;
 248         regs.ebx = mode;
 249         regs.es = seg;
 250         dpmi_int(0x10, &regs);
 251
 252         dpmi_free(sel);
 253
 254         if((regs.eax & 0xffff) != 0x4f) {
 255                 return -1;
 256         }
 257
 258         cur_pitch = vbe_getpitch();
 259         return 0;
 260 }
 261
 262 int vbe_getmode(void)
 263 {
 264         struct dpmi_regs regs = {0};
 265
 266         regs.eax = 0x4f03;
 267         dpmi_int(0x10, &regs);
 268
 269         if((regs.eax & 0xffff) != 0x4f) {
 270                 return -1;
 271         }
 272         return regs.ebx & 0xffff;
 273 }
 274
 275 int vbe_state_size(unsigned int flags)
 276 {
 277         struct dpmi_regs regs = {0};
 278
 279         regs.eax = 0x4f04;
 280         regs.edx = 0;
 281         regs.ecx = flags;
 282         dpmi_int(0x10, &regs);
 283         if((regs.eax & 0xffff) != 0x4f) {
 284                 return -1;
 285         }
 286         return (regs.ebx & 0xffff) * 64;
 287 }
 288
 289 int vbe_save(void *stbuf, int sz, unsigned int flags)
 290 {
 291         void *lowbuf;
 292         uint16_t seg, sel;
 293         struct dpmi_regs regs = {0};
 294
 295         if(!(seg = dpmi_alloc((sz + 15) / 16, &sel))) {
 296                 return -1;
 297         }
 298         lowbuf = (void*)phys_to_virt((uint32_t)seg << 4);
 299
 300         regs.eax = 0x4f04;
 301         regs.edx = 1;   /* save */
 302         regs.ecx = flags;
 303         regs.es = seg;
 304         dpmi_int(0x10, &regs);
 305         if((regs.eax & 0xffff) != 0x4f) {
 306                 dpmi_free(sel);
 307                 return -1;
 308         }
 309
 310         memcpy(stbuf, lowbuf, sz);
 311         dpmi_free(sel);
 312         return 0;
 313 }
 314
 315 int vbe_restore(void *stbuf, int sz, unsigned int flags)
 316 {
 317         void *lowbuf;
 318         uint16_t seg, sel;
 319         struct dpmi_regs regs = {0};
 320
 321         if(!(seg = dpmi_alloc((sz + 15) / 16, &sel))) {
 322                 return -1;
 323         }
 324         lowbuf = (void*)phys_to_virt((uint32_t)seg << 4);
 325
 326         memcpy(lowbuf, stbuf, sz);
 327
 328         regs.eax = 0x4f04;
 329         regs.edx = 2;   /* restore */
 330         regs.ecx = flags;
 331         regs.es = seg;
 332         dpmi_int(0x10, &regs);
 333         dpmi_free(sel);
 334         if((regs.eax & 0xffff) != 0x4f) {
 335                 return -1;
 336         }
 337         return 0;
 338 }
 339
 340 int vbe_setwin(int wid, int pos)
 341 {
 342         struct dpmi_regs regs;
 343
 344         if(wid & ~1) return -1;
 345
 346         regs.eax = 0x4f05;
 347         regs.ebx = wid;
 348         regs.edx = pos;
 349         dpmi_int(0x10, &regs);
 350
 351         if((regs.eax & 0xffff) != 0x4f) {
 352                 return -1;
 353         }
 354         return 0;
 355 }
 356
 357 int vbe_getwin(int wid)
 358 {
 359         struct dpmi_regs regs;
 360
 361         if(wid & ~1) return -1;
 362
 363         regs.eax = 0x4f05;
 364         regs.ebx = wid;
 365         dpmi_int(0x10, &regs);
 366
 367         if((regs.eax & 0xffff) != 0x4f) {
 368                 return -1;
 369         }
 370
 371         return regs.edx & 0xffff;
 372 }
 373
 374 int vbe_setscanlen(int len_pix)
 375 {
 376         struct dpmi_regs regs;
 377
 378         regs.eax = 0x4f06;
 379         regs.ebx = 0;   /* set scanline length in pixels */
 380         regs.ecx = len_pix;
 381         dpmi_int(0x10, &regs);
 382
 383         if((regs.eax & 0xffff) != 0x4f) {
 384                 return -1;
 385         }
 386
 387         cur_pitch = vbe_getpitch();
 388         return regs.ecx;
 389 }
 390
 391 int vbe_getscanlen(void)
 392 {
 393         struct dpmi_regs regs;
 394
 395         regs.eax = 0x4f06;
 396         regs.ebx = 1;   /* get scanline length */
 397         dpmi_int(0x10, &regs);
 398
 399         if((regs.eax & 0xffff) != 0x4f) {
 400                 return -1;
 401         }
 402         return regs.ecx;
 403 }
 404
 405 int vbe_getpitch(void)
 406 {
 407         struct dpmi_regs regs;
 408
 409         regs.eax = 0x4f06;
 410         regs.ebx = 1;   /* get scanline length */
 411         dpmi_int(0x10, &regs);
 412
 413         if((regs.eax & 0xffff) != 0x4f) {
 414                 return -1;
 415         }
 416         return regs.ebx;
 417 }
 418
 419 int vbe_scanline_info(struct vbe_scanline_info *sinf)
 420 {
 421         struct dpmi_regs regs;
 422
 423         regs.eax = 0x4f06;
 424         regs.ebx = 1;   /* get scanline length */
 425         dpmi_int(0x10, &regs);
 426
 427         if((regs.eax & 0xffff) != 0x4f) {
 428                 return -1;
 429         }
 430
 431         sinf->size = regs.ebx & 0xffff;
 432         sinf->num_pixels = regs.ecx & 0xffff;
 433         sinf->max_scanlines = regs.edx & 0xffff;
 434         return 0;
 435 }
 436
 437 enum {
 438         SDISP_SET                       = 0x00,
 439         SDISP_GET                       = 0x01,
 440         SDISP_ALTSET            = 0x02,
 441         SDISP_SET_STEREO        = 0x03,
 442         SDISP_GETSCHED          = 0x04,
 443         SDISP_STEREO_ON         = 0x05,
 444         SDISP_STEREO_OFF        = 0x06,
 445         SDISP_SET_VBLANK        = 0x80,
 446         SDISP_ALTSET_VBLANK     = 0x82,
 447         SDISP_SET_STEREO_VBLANK = 0x83
 448 };
 449
 450 int vbe_setdisp(int x, int y, int when)
 451 {
 452         struct dpmi_regs regs;
 453
 454         regs.eax = 0x4f07;
 455         regs.ebx = (when == VBE_SWAP_VBLANK) ? SDISP_SET_VBLANK : SDISP_SET;
 456         regs.ecx = x;
 457         regs.edx = y;
 458         dpmi_int(0x10, &regs);
 459
 460         if((regs.eax & 0xffff) != 0x4f) {
 461                 return -1;
 462         }
 463         return 0;
 464 }
 465
 466 int vbe_swap(uint32_t voffs, int when)
 467 {
 468         struct dpmi_regs regs;
 469         int op;
 470
 471         switch(when) {
 472         case VBE_SWAP_ASYNC:
 473                 op = SDISP_ALTSET;
 474                 break;
 475
 476         case VBE_SWAP_NOW:
 477                 /* XXX is this the only way? */
 478                 return vbe_setdisp(voffs % cur_pitch, voffs / cur_pitch, when);
 479
 480         case VBE_SWAP_VBLANK:
 481         default:
 482                 op = SDISP_ALTSET_VBLANK;
 483                 break;
 484         }
 485
 486
 487         regs.eax = 0x4f07;
 488         regs.ebx = op;
 489         regs.ecx = voffs;
 490         dpmi_int(0x10, &regs);
 491
 492         if((regs.eax & 0xffff) != 0x4f) {
 493                 return -1;
 494         }
 495         return 0;
 496 }
 497
 498 int vbe_swap_pending(void)
 499 {
 500         struct dpmi_regs regs;
 501
 502         regs.eax = 0x4f07;
 503         regs.ebx = SDISP_GETSCHED;
 504         dpmi_int(0x10, &regs);
 505
 506         if((regs.eax & 0xffff) != 0x4f) {
 507                 return 0;
 508         }
 509         return regs.ecx;
 510 }