/*--------------------------------------------------------------------------*/ UCHAR *GenericSvgaScreen::GetVideoAddress(void) { #if defined(DOUBLE_BUFFER) && !defined(LOCAL_BUFFERING) UCHAR* pMem = GetFrameBufferAddress( mwHRes * mwVRes * 2 ); #else UCHAR* pMem = GetFrameBufferAddress( mwHRes * mwVRes ); #endif #ifdef DPMI_API_DJGPP int ret = __djgpp_nearptr_enable(); if (ret != 0) { return NULL; } else { return NULL; } __djgpp_nearptr_disable(); #endif #ifdef DOUBLE_BUFFER # ifdef LOCAL_BUFFERING mpTargetMem = pMem; pMem = new UCHAR[mwHRes * mwVRes]; # else pMem += mwHRes * mwVRes; # endif #endif return pMem; }
static void *sys_physmap(unsigned long phys_addr, size_t len) { int ret; __dpmi_meminfo mi; /* enable 4GB limit on DS descriptor */ if (!__djgpp_nearptr_enable()) { return ERROR_PTR; } if ((phys_addr + len - 1) < (1024 * 1024)) { /* we need to use another method to map first 1MB */ return map_first_meg(phys_addr, len); } mi.address = phys_addr; mi.size = len; ret = __dpmi_physical_address_mapping (&mi); if (ret != 0) { return ERROR_PTR; } return (void *) mi.address + __djgpp_conventional_base; }
int dma_initialize() { if (!__djgpp_nearptr_enable()) return 0; /* Trick: Avoid re-setting DS selector limit on each memory allocation call */ __djgpp_selector_limit = 0xffffffff; __locked_data.address = __djgpp_base_address + (unsigned long)&dma; __locked_data.size = sizeof(dma); if (__dpmi_lock_linear_region(&__locked_data)) return 0; return (__initialized = 1); }
/* Attempts to mmap sufficient memory for the specified video mode * over the memory pointed to by vdriver_fbuf, which must be * page-aligned. Returns TRUE if successful, else FALSE. */ boolean_t vgahost_mmap_linear_fbuf (const vga_mode_t *mode) { boolean_t success_p; success_p = FALSE; /* Default */ if (mode->phys_base_addr != 0) /* do we have a linear frame buffer? */ { if (!__djgpp_map_physical_memory (vdriver_fbuf, ((mode->height * mode->row_bytes + DPMI_PAGE_SIZE - 1) & ~(DPMI_PAGE_SIZE - 1)), mode->phys_base_addr)) { success_p = TRUE; } else if (mode->screen_selector != 0 && try_to_use_fat_ds_vga_hack_p) { /* We failed to mmap it the DPMI 1.0 way, so we'll see if we * can use the fat %ds hack. */ if (__djgpp_nearptr_enable ()) { unsigned long executor_base = 0, fbuf_base = 0; if (!__dpmi_get_segment_base_address (dos_pm_ds, &executor_base) && !__dpmi_get_segment_base_address (mode->screen_selector, &fbuf_base)) { vdriver_fbuf = (uint8 *) (fbuf_base - executor_base); actually_using_fat_ds_vga_hack_p = TRUE; success_p = TRUE; } } } } if (success_p) { /* Cool beans. Note that the screen is in our address space. */ vga_screen_selector = dos_pm_ds; } return success_p; }
/** * Grab the coordinates for the line and draw * each of them */ void draw(Line *line) { if(__djgpp_nearptr_enable() == 0) { printf("Error accessing 64k of memory. Exiting"); exit(-1); } VGA += __djgpp_conventional_base; set_mode(VGA_256_COLOR_MODE); Coord *item = line->start; while(item != NULL) { plot_pixel(item->x, item->y, 100); item = item->next; } while(1 == 1) { } __djgpp_nearptr_disable(); set_mode(TEXT_MODE); }
int uip_vgamode(void) { int depth, rate; unsigned long screenbase; for (rate = 60; rate <= 70; rate += 10) { for (depth = 15; depth <= 16; depth++) { LOG_VERBOSE(("Trying mode 640x480 depth %d rate %d", depth, rate)); set_color_depth(depth); request_refresh_rate(rate); if ((set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 480 * 2) < 0)) { LOG_VERBOSE(("Mode not supported")); continue; } if (SCREEN_W != 640 || SCREEN_H != 480) { LOG_CRITICAL(("Screen not approriate for depth %d rate %d", depth, rate)); continue; } goto WHEE; } } LOG_CRITICAL(("Failed to find suitable mode")); return 1; WHEE: uip_vga = 1; if (uip_forceredshift != -1 && uip_forcegreenshift != -1 && uip_forceblueshift != -1) { uip_uipinfo->redshift = uip_forceredshift; uip_uipinfo->greenshift = uip_forcegreenshift; uip_uipinfo->blueshift = uip_forceblueshift; } else { uip_uipinfo->redshift = ui_topbit(makecol(255, 0, 0)) - 4; uip_uipinfo->greenshift = ui_topbit(makecol(0, 255, 0)) - 4; uip_uipinfo->blueshift = ui_topbit(makecol(0, 0, 255)) - 4; } if ((uip_bank0 = create_video_bitmap(640, 480)) == NULL || (uip_bank1 = create_video_bitmap(640, 480)) == NULL) { uip_textmode(); LOG_CRITICAL(("Failed to allocate memory pages")); return 1; } if (is_linear_bitmap(uip_bank0) == 0 || is_linear_bitmap(uip_bank1) == 0 || is_video_bitmap(uip_bank0) == 0 || is_video_bitmap(uip_bank1) == 0) { uip_textmode(); LOG_CRITICAL(("Allocated bitmaps not suitable or linear addressing mode " "not supported by hardware")); return 1; } /* don't you just hate MS platforms? */ __djgpp_nearptr_enable(); __dpmi_get_segment_base_address(uip_bank0->seg, &screenbase); uip_uipinfo->screenmem0 = (uint8 *)(screenbase + uip_bank0->line[0] - __djgpp_base_address); __dpmi_get_segment_base_address(uip_bank1->seg, &screenbase); uip_uipinfo->screenmem1 = (uint8 *)(screenbase + uip_bank1->line[0] - __djgpp_base_address); uip_uipinfo->linewidth = 2 * VIRTUAL_W; /* 16 bit */ uip_displaybank(0); /* set current to 0th bank */ uip_clearscreen(); /* clear bank */ ui_setupscreen(); /* setup bank */ uip_displaybank(-1); /* toggle bank */ uip_clearscreen(); /* clear bank */ ui_setupscreen(); /* setup bank */ if (install_keyboard() == -1) { uip_textmode(); LOG_CRITICAL(("Unable to initialise keyboard")); return 1; } if (uip_bank0->y_ofs != 0 || uip_bank1->y_ofs != 480) { uip_textmode(); LOG_CRITICAL(("sorry, I don't understand this video layout")); return 1; } keyboard_lowlevel_callback = uip_keyboardhandler; uip_keypoll = keyboard_needs_poll()? 1 : 0; return 0; }
int Driver_Display_Bitmap( char* buffer, int line, int col ) { int y, used_col; char* target; #ifdef DJGPP char cbuf = 0; int i; #endif #ifdef DJGPP_USE_NEAR_POINTERS if( djgpp_use_nearpointers ) if( ! __djgpp_nearptr_enable() ) /* doesn't work, probably under some real OS like NT or dosemu! */ djgpp_use_nearpointers = 0; else Vio += __djgpp_conventional_base; #endif #ifdef DJGPP if( !djgpp_use_nearpointers ) for( i = 0; i < vio_Height*vio_ScanLineWidth; i++ ) dosmemput( &cbuf, 1, (unsigned long) Vio+i ); else /*FALLTHROUGH*/ #endif memset( Vio, 0, vio_Height * vio_ScanLineWidth ); if ( line > vio_Height ) line = vio_Height; if ( col > vio_ScanLineWidth ) used_col = vio_ScanLineWidth; else used_col = col; target = Vio + ( line - 1 ) * vio_ScanLineWidth; for ( y = 0; y < line; y++ ) { #ifdef DJGPP if( !djgpp_use_nearpointers ) dosmemput( buffer, used_col, (unsigned long)target ); else /*FALLTHROUGH*/ #endif memcpy( target, buffer, used_col ); target -= vio_ScanLineWidth; buffer += col; } #ifdef DJGPP_USE_NEAR_POINTERS if( djgpp_use_nearpointers ) { Vio -= __djgpp_conventional_base; __djgpp_nearptr_disable(); } #endif return 1; /* success */ }
static int driver_init(char *title, int w, int h, int depth_arg, int refresh_rate, int flags) { int depth = MAX(8, depth_arg); int is_rgb, bpp; int red_pos, blue_pos; fb_dos_detect(); fb_dos_vesa_detect(); if (flags & DRIVER_OPENGL) return -1; if (!fb_dos.nearptr_ok) return -1; if (!fb_dos.vesa_ok) return -1; if (fb_dos_vesa_set_mode(w, h, depth, TRUE)) return -1; refresh_rate = 60; /* FIXME */ fb_dos_lock_data(&video, sizeof(video)); fb_dos_lock_data(&blitter, sizeof(blitter)); data_locked = TRUE; /* Lin* fields are only required for VBE 3.0 */ if( fb_dos.vesa_mode_info.LinRedFieldPosition == 0 && fb_dos.vesa_mode_info.LinBlueFieldPosition == 0) { red_pos = fb_dos.vesa_mode_info.RedFieldPosition; blue_pos = fb_dos.vesa_mode_info.BlueFieldPosition; } else { red_pos = fb_dos.vesa_mode_info.LinRedFieldPosition; blue_pos = fb_dos.vesa_mode_info.LinBlueFieldPosition; } is_rgb = (depth > 8) && (red_pos == 0); if (blue_pos == 10 || red_pos == 10) bpp = 15; else if (blue_pos == 11 || red_pos == 11) bpp = 16; else bpp = fb_dos.vesa_mode_info.BitsPerPixel; blitter = fb_hGetBlitter(fb_dos.vesa_mode_info.BitsPerPixel, is_rgb); if (!blitter) return -1; fb_dos.update = driver_update; fb_dos.update_len = (unsigned int)end_of_driver_update - (unsigned int)driver_update; fb_dos.set_palette = fb_dos_vesa_set_palette; __djgpp_nearptr_enable(); nearptr_enabled = TRUE; mapping.address = fb_dos.vesa_mode_info.PhysBasePtr; mapping.size = fb_dos.vesa_info.total_memory << 16; if (__dpmi_physical_address_mapping(&mapping) != 0) return -1; video = (unsigned char *)(mapping.address - __djgpp_base_address); return fb_dos_init(title, w, h, depth, refresh_rate, flags); }
int gr_init(void) { int org_gamma; int retcode; int mode = SM(320,200); // Only do this function once! if (gr_installed==1) return 3; #ifdef __DJGPP__ if (!__djgpp_nearptr_enable()) { printf("nearptr enable=%x\n", __dpmi_error); return 10; } #ifndef SAVEGR gr_video_memory = (unsigned char *)(__djgpp_conventional_base + 0xa0000); #else gr_video_memory=(unsigned char *)-1; #endif pVideoMode = (volatile ubyte *)(__djgpp_conventional_base+0x449); pNumColumns = (volatile ushort *)(__djgpp_conventional_base+0x44a); pNumRows = (volatile ubyte *)(__djgpp_conventional_base+0x484); pCharHeight = (volatile ushort *)(__djgpp_conventional_base+0x485); pCursorPos = (volatile ushort *)(__djgpp_conventional_base+0x450); pCursorType = (volatile ushort *)(__djgpp_conventional_base+0x460); pTextMemory = (volatile ushort *)(__djgpp_conventional_base+0xb8000); #endif #ifndef __DJGPP__ if (gr_init_A0000()) return 10; #endif // Save the current text screen mode if (gr_save_mode()==1) return 2; #ifndef NOGRAPH // Save the current palette, and fade it out to black. gr_palette_read( gr_pal_default ); gr_palette_faded_out = 0; org_gamma = gr_palette_get_gamma(); gr_palette_set_gamma( 0 ); gr_palette_fade_out( gr_pal_default, 32, 0 ); gr_palette_clear(); gr_palette_set_gamma( org_gamma ); gr_sync_display(); gr_sync_display(); #endif #ifdef __DJGPP__ #ifdef SAVEGR __djgpp_nearptr_disable(); #endif #endif MALLOC( grd_curscreen,grs_screen,1 ); memset( grd_curscreen, 0, sizeof(grs_screen)); // Set the mode. if ((retcode=gr_set_mode(mode))) { gr_restore_mode(); return retcode; } //JOHNgr_disable_default_palette_loading(); // Set all the screen, canvas, and bitmap variables that // aren't set by the gr_set_mode call: grd_curscreen->sc_canvas.cv_color = 0; grd_curscreen->sc_canvas.cv_drawmode = 0; grd_curscreen->sc_canvas.cv_font = NULL; grd_curscreen->sc_canvas.cv_font_fg_color = 0; grd_curscreen->sc_canvas.cv_font_bg_color = 0; gr_set_current_canvas( &grd_curscreen->sc_canvas ); #if 0 if (!dpmi_allocate_selector( &gr_fade_table, 256*GR_FADE_LEVELS, &gr_fade_table_selector )) Error( "Error allocating fade table selector!" ); if (!dpmi_allocate_selector( &gr_palette, 256*3, &gr_palette_selector )) Error( "Error allocating palette selector!" ); #endif // if (!dpmi_allocate_selector( &gr_inverse_table, 32*32*32, &gr_inverse_table_selector )) // Error( "Error allocating inverse table selector!" ); // Set flags indicating that this is installed. gr_installed = 1; #ifdef __GNUC__ atexit((void (*)) gr_close); #else atexit(gr_close); #endif return 0; }