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