14 #define VMEM_PTR ((void*)(0xa0000 + __djgpp_conventional_base))
16 #define VMEM_PTR ((void*)0xa0000)
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))
23 void (*blit_frame)(void*, int);
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);
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);
37 static struct video_mode *vmodes;
38 static int num_vmodes;
40 static int vbe_init_ver;
41 static struct vbe_info vbe;
44 static struct video_mode *curmode;
45 static void *vpgaddr[2];
46 static int frontidx, backidx;
47 static int pgcount, pgsize, fbsize;
52 int i, num, max_modes;
53 struct video_mode *vmptr;
55 if(vbe_info(&vbe) == -1) {
56 fprintf(stderr, "failed to retrieve VBE information\n");
59 vbe_print_info(stdout, &vbe);
63 if(!(vmodes = malloc(max_modes * sizeof *vmodes))) {
64 fprintf(stderr, "failed to allocate video modes list\n");
68 num = vbe_num_modes(&vbe);
69 for(i=0; i<num; i++) {
70 struct vbe_mode_info minf;
72 if(vbe_mode_info(vbe.modes[i], &minf) == -1) {
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);
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;*/
106 if(minf.attr & VBE_ATTR_LFB) {
107 vmptr->fb_addr = minf.fb_addr;
109 vmptr->max_pages = minf.num_img_pages;
110 vmptr->win_gran = minf.win_gran;
112 printf("%04x: ", vbe.modes[i]);
113 vbe_print_mode_info(stdout, &minf);
117 vbe_init_ver = VBE_VER_MAJOR(vbe.ver);
121 void cleanup_video(void)
126 struct video_mode *video_modes(void)
131 int num_video_modes(void)
136 struct video_mode *get_video_mode(int idx)
138 if(idx == VMODE_CURRENT) {
144 int match_video_mode(int xsz, int ysz, int bpp)
147 struct video_mode *vm;
149 for(i=0; i<num_vmodes; i++) {
151 if(vm->xsz != xsz || vm->ysz != ysz) continue;
152 if(SAME_BPP(vm->bpp, bpp)) {
155 if(vm->bpp == bpp) break;
159 fprintf(stderr, "failed to find video mode %dx%d %d bpp)\n", xsz, ysz, bpp);
165 int find_video_mode(int mode)
168 struct video_mode *vm;
171 for(i=0; i<num_vmodes; i++) {
172 if(vm->mode == mode) return i;
177 void *set_video_mode(int idx, int nbuf)
180 struct video_mode *vm = vmodes + idx;
182 if(curmode == vm) return vpgaddr[0];
184 printf("setting video mode %x (%dx%d %d bpp)\n", (unsigned int)vm->mode,
185 vm->xsz, vm->ysz, vm->bpp);
188 mode = vm->mode | VBE_MODE_LFB;
189 if(vbe_setmode(mode) == -1) {
191 if(vbe_setmode(mode) == -1) {
192 fprintf(stderr, "failed to set video mode %x\n", (unsigned int)vm->mode);
195 printf("Warning: failed to get a linear framebuffer. falling back to banked mode\n");
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;
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;
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);
216 printf("pgcount: %d, pgsize: %d, fbsize: %d\n", pgcount, pgsize, fbsize);
218 printf("phys addr: %p\n", (void*)vm->fb_addr);
223 vpgaddr[0] = (void*)dpmi_mmap(vm->fb_addr, fbsize);
225 fprintf(stderr, "failed to map framebuffer (phys: %lx, size: %d)\n",
226 (unsigned long)vm->fb_addr, fbsize);
230 memset(vpgaddr[0], 0xaa, pgsize);
233 vpgaddr[1] = (char*)vpgaddr[0] + pgsize;
235 page_flip(FLIP_NOW); /* start with the second page visible */
237 frontidx = backidx = 0;
241 blit_frame = dblsize ? blit_frame_lfb_2x : blit_frame_lfb;
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
249 fprintf(stderr, "Can't set framebuffer range to write-combining, running in ring %d\n", cpl);
251 uint32_t len = (uint32_t)vbe.vmem_blk << 16;
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
257 if(!len || len > 0x10000000) {
258 printf("reported vmem too large or overflowed, using fbsize for wrcomb setup\n");
262 enable_wrcomb(vm->fb_addr, len);
267 vpgaddr[0] = VMEM_PTR;
270 blit_frame = dblsize ? blit_frame_banked_2x : blit_frame_banked;
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;
278 vm->win_gran_shift++;
281 vm->win_64k_step = 1 << vm->win_gran_shift;
284 printf("granularity: %dk (step: %d)\n", vm->win_gran, vm->win_64k_step);
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,
299 int set_text_mode(void)
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;
312 void *page_flip(int vsync)
315 /* page flipping not supported */
319 vbe_swap(backidx ? pgsize : 0, vsync ? VBE_SWAP_VBLANK : VBE_SWAP_NOW);
321 backidx = (backidx + 1) & 1;
323 return vpgaddr[backidx];
327 static void blit_frame_lfb(void *pixels, int vsync)
329 demo_post_draw(pixels);
331 if(vsync) wait_vsync();
332 memcpy64(vpgaddr[frontidx], pixels, pgsize >> 3);
335 static void blit_frame_banked(void *pixels, int vsync)
337 int sz, offs, pending;
338 unsigned char *pptr = pixels;
340 demo_post_draw(pixels);
342 if(vsync) wait_vsync();
344 /* assume initial window offset at 0 */
348 sz = pending > 65536 ? 65536 : pending;
349 /*memcpy64(VMEM_PTR, pptr, sz >> 3);*/
350 memcpy(VMEM_PTR, pptr, sz);
353 offs += curmode->win_64k_step;
359 static void blit_frame_lfb_2x(void *pixels, int vsync)
361 demo_post_draw(pixels);
363 if(vsync) wait_vsync();
364 memcpy64(vpgaddr[frontidx], pixels, pgsize >> 3);
367 static void blit_frame_banked_2x(void *pixels, int vsync)
369 int sz, offs, pending;
370 unsigned char *pptr = pixels;
372 demo_post_draw(pixels);
374 if(vsync) wait_vsync();
376 /* assume initial window offset at 0 */
380 sz = pending > 65536 ? 65536 : pending;
381 /*memcpy64(VMEM_PTR, pptr, sz >> 3);*/
382 memcpy(VMEM_PTR, pptr, sz);
385 offs += curmode->win_64k_step;
391 static uint32_t calc_mask(int sz, int pos)
395 mask = (mask << 1) | 1;
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
410 static int get_page_memtype(uint32_t addr, int num_ranges)
413 uint32_t rlow, rhigh;
416 for(i=0; i<num_ranges; i++) {
417 get_msr(MSR_MTRRMASK(i), &rlow, &rhigh);
418 if(!(rlow & MTRRMASK_VALID)) {
421 mask = rlow & 0xfffff000;
423 get_msr(MSR_MTRRBASE(i), &rlow, &rhigh);
424 base = rlow & 0xfffff000;
426 if((addr & mask) == (base & mask)) {
431 get_msr(MSR_MTRRDEFTYPE, &rlow, &rhigh);
435 static int check_wrcomb_enabled(uint32_t addr, int len, int num_ranges)
438 if(get_page_memtype(addr, num_ranges) != MTRR_WC) {
447 static int alloc_mtrr(int num_ranges)
450 uint32_t rlow, rhigh;
452 for(i=0; i<num_ranges; i++) {
453 get_msr(MSR_MTRRMASK(i), &rlow, &rhigh);
454 if(!(rlow & MTRRMASK_VALID)) {
461 static void enable_wrcomb(uint32_t addr, int len)
463 int num_ranges, mtrr;
464 uint32_t rlow, rhigh;
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);
473 get_msr(MSR_MTRRCAP, &rlow, &rhigh);
474 num_ranges = rlow & 0xff;
476 printf("enable_wrcomb: addr=%p len=%x\n", (void*)addr, (unsigned int)len);
478 if(!(rlow & MTRRCAP_HAVE_WC)) {
479 fprintf(stderr, "failed to enable write combining, processor doesn't support it\n");
483 if(check_wrcomb_enabled(addr, len, num_ranges)) {
487 if((mtrr = alloc_mtrr(num_ranges)) == -1) {
488 fprintf(stderr, "failed to enable write combining, no free MTRRs\n");
498 mask = ~mask & 0xfffff000;
500 printf(" ... mask: %08x\n", (unsigned int)mask);
503 get_msr(MSR_MTRRDEFTYPE, &def, &rhigh);
504 set_msr(MSR_MTRRDEFTYPE, def & ~MTRRDEF_EN, rhigh);
506 set_msr(MSR_MTRRBASE(mtrr), addr | MTRR_WC, 0);
507 set_msr(MSR_MTRRMASK(mtrr), mask | MTRRMASK_VALID, 0);
509 set_msr(MSR_MTRRDEFTYPE, def | MTRRDEF_EN, 0);
513 static const char *mtrr_names[] = { "N/A", "W C", "N/A", "N/A", "W T", "W P", "W B" };
515 static const char *mtrr_type_name(int type)
517 if(type < 0 || type >= sizeof mtrr_names / sizeof *mtrr_names) {
518 return mtrr_names[0];
520 return mtrr_names[type];
523 static void print_mtrr(void)
526 uint32_t rlow, rhigh, base, mask;
528 get_msr(MSR_MTRRCAP, &rlow, &rhigh);
529 num_ranges = rlow & 0xff;
531 for(i=0; i<num_ranges; i++) {
532 get_msr(MSR_MTRRBASE(i), &base, &rhigh);
533 get_msr(MSR_MTRRMASK(i), &mask, &rhigh);
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));
539 printf("mtrr%d unused (%08x/%08x)\n", i, (unsigned int)base,