/*--------------------------------------------------------------------------*/
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;
}
