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

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