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