git.mutantstargoat.com Git - dos_imgv/blob - src/video.c

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