git.mutantstargoat.com Git - retroray/blob - src/dos/gfx.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <dos.h>
   5 #include "app.h"
   6 #include "cdpmi.h"
   7 #include "gfx.h"
   8 #include "vbe.h"
   9 #include "vga.h"
  10 #include "util.h"
  11 #include "cpuid.h"
  12
  13 #ifdef __DJGPP__
  14 #define VMEM_PTR        ((void*)(0xa0000 + __djgpp_conventional_base))
  15 #else
  16 #define VMEM_PTR        ((void*)0xa0000)
  17 #endif
  18
  19 #define SAME_BPP(a, b)  \
  20         ((a) == (b) || ((a) == 16 && (b) == 15) || ((a) == 15 && (b) == 16) || \
  21          ((a) == 32 && (b) == 24) || ((a) == 24 && (b) == 32))
  22
  23 void (*blit_frame)(void*, int);
  24
  25 extern int dblsize;
  26
  27 static void blit_frame_lfb(void *pixels, int vsync);
  28 static void blit_frame_banked(void *pixels, int vsync);
  29 static void blit_frame_lfb_2x(void *pixels, int vsync);
  30 static void blit_frame_banked_2x(void *pixels, int vsync);
  31 static uint32_t calc_mask(int sz, int pos);
  32
  33 static void enable_wrcomb(uint32_t addr, int len);
  34 static const char *mtrr_type_name(int type);
  35 static void print_mtrr(void);
  36
  37 static struct video_mode *vmodes;
  38 static int num_vmodes;
  39
  40 static int vbe_init_ver;
  41 static struct vbe_info vbe;
  42
  43 /* current mode */
  44 static struct video_mode *curmode;
  45 static void *vpgaddr[2];
  46 static int frontidx, backidx;
  47 static int pgcount, pgsize, fbsize;
  48
  49
  50 int init_video(void)
  51 {
  52         int i, num, max_modes;
  53         struct video_mode *vmptr;
  54
  55         if(vbe_info(&vbe) == -1) {
  56                 fprintf(stderr, "failed to retrieve VBE information\n");
  57                 return -1;
  58         }
  59         vbe_print_info(stdout, &vbe);
  60
  61         num_vmodes = 0;
  62         max_modes = 64;
  63         if(!(vmodes = malloc(max_modes * sizeof *vmodes))) {
  64                 fprintf(stderr, "failed to allocate video modes list\n");
  65                 return -1;
  66         }
  67
  68         num = vbe_num_modes(&vbe);
  69         for(i=0; i<num; i++) {
  70                 struct vbe_mode_info minf;
  71
  72                 if(vbe_mode_info(vbe.modes[i], &minf) == -1) {
  73                         continue;
  74                 }
  75
  76                 if(num_vmodes >= max_modes) {
  77                         int newmax = max_modes ? (max_modes << 1) : 16;
  78                         if(!(vmptr = realloc(vmodes, newmax * sizeof *vmodes))) {
  79                                 fprintf(stderr, "failed to grow video mode list (%d)\n", newmax);
  80                                 free(vmodes);
  81                                 return -1;
  82                         }
  83                         vmodes = vmptr;
  84                         max_modes = newmax;
  85                 }
  86
  87                 vmptr = vmodes + num_vmodes++;
  88                 memset(vmptr, 0, sizeof *vmptr);
  89                 vmptr->mode = vbe.modes[i];
  90                 vmptr->xsz = minf.xres;
  91                 vmptr->ysz = minf.yres;
  92                 vmptr->bpp = minf.bpp;
  93                 vmptr->pitch = minf.scanline_bytes;
  94                 if(minf.mem_model == VBE_TYPE_DIRECT) {
  95                         vmptr->rbits = minf.rsize;
  96                         vmptr->gbits = minf.gsize;
  97                         vmptr->bbits = minf.bsize;
  98                         vmptr->rshift = minf.rpos;
  99                         vmptr->gshift = minf.gpos;
 100                         vmptr->bshift = minf.bpos;
 101                         vmptr->rmask = calc_mask(minf.rsize, minf.rpos);
 102                         vmptr->gmask = calc_mask(minf.gsize, minf.gpos);
 103                         vmptr->bmask = calc_mask(minf.bsize, minf.bpos);
 104                         /*vmptr->bpp = vmptr->rbits + vmptr->gbits + vmptr->bbits;*/
 105                 }
 106                 if(minf.attr & VBE_ATTR_LFB) {
 107                         vmptr->fb_addr = minf.fb_addr;
 108                 }
 109                 vmptr->max_pages = minf.num_img_pages;
 110                 vmptr->win_gran = minf.win_gran;
 111
 112                 printf("%04x: ", vbe.modes[i]);
 113                 vbe_print_mode_info(stdout, &minf);
 114         }
 115         fflush(stdout);
 116
 117         vbe_init_ver = VBE_VER_MAJOR(vbe.ver);
 118         return 0;
 119 }
 120
 121 void cleanup_video(void)
 122 {
 123         free(vmodes);
 124 }
 125
 126 struct video_mode *video_modes(void)
 127 {
 128         return vmodes;
 129 }
 130
 131 int num_video_modes(void)
 132 {
 133         return num_vmodes;
 134 }
 135
 136 struct video_mode *get_video_mode(int idx)
 137 {
 138         if(idx == VMODE_CURRENT) {
 139                 return curmode;
 140         }
 141         return vmodes + idx;
 142 }
 143
 144 int match_video_mode(int xsz, int ysz, int bpp)
 145 {
 146         int i, best = -1;
 147         struct video_mode *vm;
 148
 149         for(i=0; i<num_vmodes; i++) {
 150                 vm = vmodes + i;
 151                 if(vm->xsz != xsz || vm->ysz != ysz) continue;
 152                 if(SAME_BPP(vm->bpp, bpp)) {
 153                         best = i;
 154                 }
 155                 if(vm->bpp == bpp) break;
 156         }
 157
 158         if(best == -1) {
 159                 fprintf(stderr, "failed to find video mode %dx%d %d bpp)\n", xsz, ysz, bpp);
 160                 return -1;
 161         }
 162         return best;
 163 }
 164
 165 int find_video_mode(int mode)
 166 {
 167         int i;
 168         struct video_mode *vm;
 169
 170         vm = vmodes;
 171         for(i=0; i<num_vmodes; i++) {
 172                 if(vm->mode == mode) return i;
 173         }
 174         return -1;
 175 }
 176
 177 void *set_video_mode(int idx, int nbuf)
 178 {
 179         unsigned int mode;
 180         struct video_mode *vm = vmodes + idx;
 181
 182         if(curmode == vm) return vpgaddr[0];
 183
 184         printf("setting video mode %x (%dx%d %d bpp)\n", (unsigned int)vm->mode,
 185                         vm->xsz, vm->ysz, vm->bpp);
 186         fflush(stdout);
 187
 188         mode = vm->mode | VBE_MODE_LFB;
 189         if(vbe_setmode(mode) == -1) {
 190                 mode = vm->mode;
 191                 if(vbe_setmode(mode) == -1) {
 192                         fprintf(stderr, "failed to set video mode %x\n", (unsigned int)vm->mode);
 193                         return 0;
 194                 }
 195                 printf("Warning: failed to get a linear framebuffer. falling back to banked mode\n");
 196         }
 197
 198         /* unmap previous video memory mapping, if there was one (switching modes) */
 199         if(vpgaddr[0] && vpgaddr[0] != VMEM_PTR) {
 200                 dpmi_munmap(vpgaddr[0]);
 201                 vpgaddr[0] = vpgaddr[1] = 0;
 202         }
 203
 204         curmode = vm;
 205         if(nbuf < 1) nbuf = 1;
 206         if(nbuf > 2) nbuf = 2;
 207         pgcount = nbuf > vm->max_pages + 1 ? vm->max_pages + 1 : nbuf;
 208         pgsize = vm->ysz * vm->pitch;
 209         fbsize = pgcount * pgsize;
 210
 211         if(vm->bpp > 8) {
 212                 printf("rgb mask: %x %x %x\n", (unsigned int)vm->rmask,
 213                                 (unsigned int)vm->gmask, (unsigned int)vm->bmask);
 214                 printf("rgb shift: %d %d %d\n", vm->rshift, vm->gshift, vm->bshift);
 215         }
 216         printf("pgcount: %d, pgsize: %d, fbsize: %d\n", pgcount, pgsize, fbsize);
 217         if(vm->fb_addr) {
 218                 printf("phys addr: %p\n", (void*)vm->fb_addr);
 219         }
 220         fflush(stdout);
 221
 222         if(vm->fb_addr) {
 223                 vpgaddr[0] = (void*)dpmi_mmap(vm->fb_addr, fbsize);
 224                 if(!vpgaddr[0]) {
 225                         fprintf(stderr, "failed to map framebuffer (phys: %lx, size: %d)\n",
 226                                         (unsigned long)vm->fb_addr, fbsize);
 227                         set_text_mode();
 228                         return 0;
 229                 }
 230                 memset(vpgaddr[0], 0xaa, pgsize);
 231
 232                 if(pgcount > 1) {
 233                         vpgaddr[1] = (char*)vpgaddr[0] + pgsize;
 234                         backidx = 1;
 235                         page_flip(FLIP_NOW);    /* start with the second page visible */
 236                 } else {
 237                         frontidx = backidx = 0;
 238                         vpgaddr[1] = 0;
 239                 }
 240
 241                 blit_frame = dblsize ? blit_frame_lfb_2x : blit_frame_lfb;
 242
 243                 /* only attempt to set up write combining if the CPU we're running on
 244                  * supports memory type range registers, and we're running on ring 0
 245                  */
 246                 if(CPU_HAVE_MTRR) {
 247                         int cpl = get_cpl();
 248                         if(cpl > 0) {
 249                                 fprintf(stderr, "Can't set framebuffer range to write-combining, running in ring %d\n", cpl);
 250                         } else {
 251                                 uint32_t len = (uint32_t)vbe.vmem_blk << 16;
 252
 253                                 /* if vmem_blk is 0 or if the reported size is absurd (more than
 254                                  * 256mb), just use the framebuffer size for this mode to setup the
 255                                  * mtrr
 256                                  */
 257                                 if(!len || len > 0x10000000) {
 258                                         printf("reported vmem too large or overflowed, using fbsize for wrcomb setup\n");
 259                                         len = fbsize;
 260                                 }
 261                                 print_mtrr();
 262                                 enable_wrcomb(vm->fb_addr, len);
 263                         }
 264                 }
 265
 266         } else {
 267                 vpgaddr[0] = VMEM_PTR;
 268                 vpgaddr[1] = 0;
 269
 270                 blit_frame = dblsize ? blit_frame_banked_2x : blit_frame_banked;
 271
 272                 /* calculate window granularity shift */
 273                 vm->win_gran_shift = 0;
 274                 vm->win_64k_step = 1;
 275                 if(vm->win_gran > 0 && vm->win_gran < 64) {
 276                         int gran = vm->win_gran;
 277                         while(gran < 64) {
 278                                 vm->win_gran_shift++;
 279                                 gran <<= 1;
 280                         }
 281                         vm->win_64k_step = 1 << vm->win_gran_shift;
 282                 }
 283
 284                 printf("granularity: %dk (step: %d)\n", vm->win_gran, vm->win_64k_step);
 285         }
 286
 287         /* allocate main memory framebuffer */
 288         if(demo_resizefb(vm->xsz, vm->ysz, vm->bpp) == -1) {
 289                 fprintf(stderr, "failed to allocate %dx%d (%d bpp) framebuffer\n", vm->xsz,
 290                                 vm->ysz, vm->bpp);
 291                 set_text_mode();
 292                 return 0;
 293         }
 294
 295         fflush(stdout);
 296         return vpgaddr[0];
 297 }
 298
 299 int set_text_mode(void)
 300 {
 301         /* unmap previous video memory mapping, if there was one (switching modes) */
 302         if(vpgaddr[0] && vpgaddr[0] != VMEM_PTR) {
 303                 dpmi_munmap(vpgaddr[0]);
 304                 vpgaddr[0] = vpgaddr[1] = 0;
 305         }
 306
 307         vga_setmode(3);
 308         curmode = 0;
 309         return 0;
 310 }
 311
 312 void *page_flip(int vsync)
 313 {
 314         if(!vpgaddr[1]) {
 315                 /* page flipping not supported */
 316                 return vpgaddr[0];
 317         }
 318
 319         vbe_swap(backidx ? pgsize : 0, vsync ? VBE_SWAP_VBLANK : VBE_SWAP_NOW);
 320         frontidx = backidx;
 321         backidx = (backidx + 1) & 1;
 322
 323         return vpgaddr[backidx];
 324 }
 325
 326
 327 static void blit_frame_lfb(void *pixels, int vsync)
 328 {
 329         demo_post_draw(pixels);
 330
 331         if(vsync) wait_vsync();
 332         memcpy64(vpgaddr[frontidx], pixels, pgsize >> 3);
 333 }
 334
 335 static void blit_frame_banked(void *pixels, int vsync)
 336 {
 337         int sz, offs, pending;
 338         unsigned char *pptr = pixels;
 339
 340         demo_post_draw(pixels);
 341
 342         if(vsync) wait_vsync();
 343
 344         /* assume initial window offset at 0 */
 345         offs = 0;
 346         pending = pgsize;
 347         while(pending > 0) {
 348                 sz = pending > 65536 ? 65536 : pending;
 349                 /*memcpy64(VMEM_PTR, pptr, sz >> 3);*/
 350                 memcpy(VMEM_PTR, pptr, sz);
 351                 pptr += sz;
 352                 pending -= sz;
 353                 offs += curmode->win_64k_step;
 354                 vbe_setwin(0, offs);
 355         }
 356         vbe_setwin(0, 0);
 357 }
 358
 359 static void blit_frame_lfb_2x(void *pixels, int vsync)
 360 {
 361         demo_post_draw(pixels);
 362
 363         if(vsync) wait_vsync();
 364         memcpy64(vpgaddr[frontidx], pixels, pgsize >> 3);
 365 }
 366
 367 static void blit_frame_banked_2x(void *pixels, int vsync)
 368 {
 369         int sz, offs, pending;
 370         unsigned char *pptr = pixels;
 371
 372         demo_post_draw(pixels);
 373
 374         if(vsync) wait_vsync();
 375
 376         /* assume initial window offset at 0 */
 377         offs = 0;
 378         pending = pgsize;
 379         while(pending > 0) {
 380                 sz = pending > 65536 ? 65536 : pending;
 381                 /*memcpy64(VMEM_PTR, pptr, sz >> 3);*/
 382                 memcpy(VMEM_PTR, pptr, sz);
 383                 pptr += sz;
 384                 pending -= sz;
 385                 offs += curmode->win_64k_step;
 386                 vbe_setwin(0, offs);
 387         }
 388         vbe_setwin(0, 0);
 389 }
 390
 391 static uint32_t calc_mask(int sz, int pos)
 392 {
 393         uint32_t mask = 0;
 394         while(sz-- > 0) {
 395                 mask = (mask << 1) | 1;
 396         }
 397         return mask << pos;
 398 }
 399
 400 #define MSR_MTRRCAP                     0xfe
 401 #define MSR_MTRRDEFTYPE         0x2ff
 402 #define MSR_MTRRBASE(x)         (0x200 | ((x) << 1))
 403 #define MSR_MTRRMASK(x)         (0x201 | ((x) << 1))
 404 #define MTRRDEF_EN                      0x800
 405 #define MTRRCAP_HAVE_WC         0x400
 406 #define MTRRMASK_VALID          0x800
 407
 408 #define MTRR_WC                         1
 409
 410 static int get_page_memtype(uint32_t addr, int num_ranges)
 411 {
 412         int i;
 413         uint32_t rlow, rhigh;
 414         uint32_t base, mask;
 415
 416         for(i=0; i<num_ranges; i++) {
 417                 get_msr(MSR_MTRRMASK(i), &rlow, &rhigh);
 418                 if(!(rlow & MTRRMASK_VALID)) {
 419                         continue;
 420                 }
 421                 mask = rlow & 0xfffff000;
 422
 423                 get_msr(MSR_MTRRBASE(i), &rlow, &rhigh);
 424                 base = rlow & 0xfffff000;
 425
 426                 if((addr & mask) == (base & mask)) {
 427                         return rlow & 0xff;
 428                 }
 429         }
 430
 431         get_msr(MSR_MTRRDEFTYPE, &rlow, &rhigh);
 432         return rlow & 0xff;
 433 }
 434
 435 static int check_wrcomb_enabled(uint32_t addr, int len, int num_ranges)
 436 {
 437         while(len > 0) {
 438                 if(get_page_memtype(addr, num_ranges) != MTRR_WC) {
 439                         return 0;
 440                 }
 441                 addr += 4096;
 442                 len -= 4096;
 443         }
 444         return 1;
 445 }
 446
 447 static int alloc_mtrr(int num_ranges)
 448 {
 449         int i;
 450         uint32_t rlow, rhigh;
 451
 452         for(i=0; i<num_ranges; i++) {
 453                 get_msr(MSR_MTRRMASK(i), &rlow, &rhigh);
 454                 if(!(rlow & MTRRMASK_VALID)) {
 455                         return i;
 456                 }
 457         }
 458         return -1;
 459 }
 460
 461 static void enable_wrcomb(uint32_t addr, int len)
 462 {
 463         int num_ranges, mtrr;
 464         uint32_t rlow, rhigh;
 465         uint32_t def, mask;
 466
 467         if(len <= 0 || (addr | (uint32_t)len) & 0xfff) {
 468                 fprintf(stderr, "failed to enable write combining, unaligned range: %p/%x\n",
 469                                 (void*)addr, (unsigned int)len);
 470                 return;
 471         }
 472
 473         get_msr(MSR_MTRRCAP, &rlow, &rhigh);
 474         num_ranges = rlow & 0xff;
 475
 476         printf("enable_wrcomb: addr=%p len=%x\n", (void*)addr, (unsigned int)len);
 477
 478         if(!(rlow & MTRRCAP_HAVE_WC)) {
 479                 fprintf(stderr, "failed to enable write combining, processor doesn't support it\n");
 480                 return;
 481         }
 482
 483         if(check_wrcomb_enabled(addr, len, num_ranges)) {
 484                 return;
 485         }
 486
 487         if((mtrr = alloc_mtrr(num_ranges)) == -1) {
 488                 fprintf(stderr, "failed to enable write combining, no free MTRRs\n");
 489                 return;
 490         }
 491
 492         mask = len - 1;
 493         mask |= mask >> 1;
 494         mask |= mask >> 2;
 495         mask |= mask >> 4;
 496         mask |= mask >> 8;
 497         mask |= mask >> 16;
 498         mask = ~mask & 0xfffff000;
 499
 500         printf("  ... mask: %08x\n", (unsigned int)mask);
 501
 502         _disable();
 503         get_msr(MSR_MTRRDEFTYPE, &def, &rhigh);
 504         set_msr(MSR_MTRRDEFTYPE, def & ~MTRRDEF_EN, rhigh);
 505
 506         set_msr(MSR_MTRRBASE(mtrr), addr | MTRR_WC, 0);
 507         set_msr(MSR_MTRRMASK(mtrr), mask | MTRRMASK_VALID, 0);
 508
 509         set_msr(MSR_MTRRDEFTYPE, def | MTRRDEF_EN, 0);
 510         _enable();
 511 }
 512
 513 static const char *mtrr_names[] = { "N/A", "W C", "N/A", "N/A", "W T", "W P", "W B" };
 514
 515 static const char *mtrr_type_name(int type)
 516 {
 517         if(type < 0 || type >= sizeof mtrr_names / sizeof *mtrr_names) {
 518                 return mtrr_names[0];
 519         }
 520         return mtrr_names[type];
 521 }
 522
 523 static void print_mtrr(void)
 524 {
 525         int i, num_ranges;
 526         uint32_t rlow, rhigh, base, mask;
 527
 528         get_msr(MSR_MTRRCAP, &rlow, &rhigh);
 529         num_ranges = rlow & 0xff;
 530
 531         for(i=0; i<num_ranges; i++) {
 532                 get_msr(MSR_MTRRBASE(i), &base, &rhigh);
 533                 get_msr(MSR_MTRRMASK(i), &mask, &rhigh);
 534
 535                 if(mask & MTRRMASK_VALID) {
 536                         printf("mtrr%d: base %p, mask %08x type %s\n", i, (void*)(base & 0xfffff000),
 537                                         (unsigned int)(mask & 0xfffff000), mtrr_type_name(base & 0xff));
 538                 } else {
 539                         printf("mtrr%d unused (%08x/%08x)\n", i, (unsigned int)base,
 540                                         (unsigned int)mask);
 541                 }
 542         }
 543         fflush(stdout);
 544 }