| 1 | /*
|
|---|
| 2 | ** Copyright 2002-2005, Michael Noisternig. All rights reserved.
|
|---|
| 3 | ** Distributed under the terms of the NewOS License.
|
|---|
| 4 | */
|
|---|
| 5 | #include "vesa3.h"
|
|---|
| 6 | #include "gtf.h"
|
|---|
| 7 | #include "video_param_table.h"
|
|---|
| 8 |
|
|---|
| 9 | #include <kernel/debug.h>
|
|---|
| 10 | #include <kernel/fs/devfs.h>
|
|---|
| 11 | #include <kernel/arch/i386/selector.h>
|
|---|
| 12 | #include <kernel/vm.h>
|
|---|
| 13 | #include <kernel/heap.h>
|
|---|
| 14 | #include <string.h>
|
|---|
| 15 | #include <stdio.h>
|
|---|
| 16 | #include <newos/errors.h>
|
|---|
| 17 | #include <newos/drivers.h>
|
|---|
| 18 |
|
|---|
| 19 | //-----------------------------------------------------------------------------
|
|---|
| 20 |
|
|---|
| 21 | // set for reading the BIOS from array biosdata - useful for debugging
|
|---|
| 22 | //#define FAKE_VESA
|
|---|
| 23 |
|
|---|
| 24 | // NOTE: many VESA VBE 3.0 implementations are broken
|
|---|
| 25 | // I try to address these problems by patching the copy of the BIOS in RAM
|
|---|
| 26 |
|
|---|
| 27 | //----------------------------------------------------------------------------
|
|---|
| 28 |
|
|---|
| 29 | #ifdef FAKE_VESA
|
|---|
| 30 | //#include "sapphire9200.h"
|
|---|
| 31 | #include "nv4193e.h"
|
|---|
| 32 | //#include "vivid!81.h"
|
|---|
| 33 | //#include "prophet3.h"
|
|---|
| 34 | #endif
|
|---|
| 35 |
|
|---|
| 36 | #define STRING2(s) #s
|
|---|
| 37 | #define STRING(s) STRING2(s)
|
|---|
| 38 |
|
|---|
| 39 | struct s_regs {
|
|---|
| 40 | uint16 ax;
|
|---|
| 41 | uint16 bx;
|
|---|
| 42 | uint16 cx;
|
|---|
| 43 | uint16 dx;
|
|---|
| 44 | uint16 si;
|
|---|
| 45 | uint16 di;
|
|---|
| 46 | uint16 es;
|
|---|
| 47 | } _PACKED;
|
|---|
| 48 |
|
|---|
| 49 | static devfs_framebuffer_info fb_info;
|
|---|
| 50 |
|
|---|
| 51 | static vesa3_infoblock infoblock;
|
|---|
| 52 | static vesa3_mode_infoblock mode_infoblock;
|
|---|
| 53 |
|
|---|
| 54 | static selector_id sel_infoblock;
|
|---|
| 55 |
|
|---|
| 56 | static unsigned char *video_bios;
|
|---|
| 57 | static unsigned char *bios_data;
|
|---|
| 58 | static unsigned char *bios_stack;
|
|---|
| 59 |
|
|---|
| 60 | static selector_id sel_code;
|
|---|
| 61 | static selector_id sel_stack;
|
|---|
| 62 |
|
|---|
| 63 | static int retn; // for 16-bit far return or 32-bit near return
|
|---|
| 64 |
|
|---|
| 65 | extern void vesa3_dummy_retf();
|
|---|
| 66 | extern void vesa3_call_retf();
|
|---|
| 67 | asm(
|
|---|
| 68 | ".global vesa3_call_retf;"
|
|---|
| 69 | "vesa3_call_retf:;"
|
|---|
| 70 | //"pushl %ds;"
|
|---|
| 71 | //"popl %gs;"
|
|---|
| 72 | //"pushl $0x40;"
|
|---|
| 73 | //"popl %ds;"
|
|---|
| 74 | " addr16;"
|
|---|
| 75 | " lcall *retn;"
|
|---|
| 76 | //" lcall %gs:*retn;"
|
|---|
| 77 | " data16;"
|
|---|
| 78 | ".global vesa3_dummy_retf;"
|
|---|
| 79 | "vesa3_dummy_retf:;"
|
|---|
| 80 | " lret;"
|
|---|
| 81 | );
|
|---|
| 82 |
|
|---|
| 83 | static struct s_farcall {
|
|---|
| 84 | uint32 offset;
|
|---|
| 85 | uint32 seg;
|
|---|
| 86 | } farcall = { (uint32)vesa3_dummy_retf, KERNEL_CODE_SEG };
|
|---|
| 87 |
|
|---|
| 88 | static void vesa_call( struct s_regs *regs )
|
|---|
| 89 | {
|
|---|
| 90 | asm("pushf;"
|
|---|
| 91 | "cli;"
|
|---|
| 92 | "pushl %%es;"
|
|---|
| 93 | "pushal;"
|
|---|
| 94 | "movl %%esp,%%esi;"
|
|---|
| 95 | "pushl sel_stack;"
|
|---|
| 96 | "pushl $("STRING(VESA_STACK_SIZE)"-4);"
|
|---|
| 97 | "call i386_stack_switch;"
|
|---|
| 98 | "pushl $"STRING(KERNEL_DATA_SEG)";"
|
|---|
| 99 | "pushl %%esi;"
|
|---|
| 100 | "pushl %%edi;"
|
|---|
| 101 | "pushl %%ds;"
|
|---|
| 102 | "movw 12(%%edi),%%dx;"
|
|---|
| 103 | "movw %%dx,%%es;"
|
|---|
| 104 | "movw (%%edi),%%ax;"
|
|---|
| 105 | "movw 2(%%edi),%%bx;"
|
|---|
| 106 | "movw 4(%%edi),%%cx;"
|
|---|
| 107 | "movw 6(%%edi),%%dx;"
|
|---|
| 108 | "movw 8(%%edi),%%si;"
|
|---|
| 109 | "movw 10(%%edi),%%di;"
|
|---|
| 110 | "lcall *farcall;"
|
|---|
| 111 | "popl %%ds;"
|
|---|
| 112 | "popl %%ebp;"
|
|---|
| 113 | "movw %%ax,%%ds:(%%ebp);"
|
|---|
| 114 | "movl %%ebp,%%eax;"
|
|---|
| 115 | "movw %%bx,2(%%eax);"
|
|---|
| 116 | "movw %%cx,4(%%eax);"
|
|---|
| 117 | "movw %%dx,6(%%eax);"
|
|---|
| 118 | "movw %%si,8(%%eax);"
|
|---|
| 119 | "movw %%di,10(%%eax);"
|
|---|
| 120 | "movw %%es,%%bx;"
|
|---|
| 121 | "movw %%bx,12(%%eax);"
|
|---|
| 122 | "call i386_stack_switch;"
|
|---|
| 123 | "popal;"
|
|---|
| 124 | "popl %%es;"
|
|---|
| 125 | "popf;"
|
|---|
| 126 | : : "D" (regs) );
|
|---|
| 127 | }
|
|---|
| 128 |
|
|---|
| 129 | //----------------------------------------------------------------------------
|
|---|
| 130 |
|
|---|
| 131 | #if 0
|
|---|
| 132 | static void *linear( void *ptr )
|
|---|
| 133 | {
|
|---|
| 134 | return (void *)( *(unsigned short *)ptr + ((int)(((unsigned short *)ptr)[1])<<4) );
|
|---|
| 135 | }
|
|---|
| 136 | #endif
|
|---|
| 137 |
|
|---|
| 138 | static void *memmem( const void *mem, size_t len, const void *submem, size_t sublen )
|
|---|
| 139 | {
|
|---|
| 140 | const char *m = mem;
|
|---|
| 141 | const char *max = &m[len-sublen];
|
|---|
| 142 |
|
|---|
| 143 | for ( ; m < max; m++ ) {
|
|---|
| 144 | m = memchr( m, *(char *)submem, max-m );
|
|---|
| 145 | if ( m == NULL )
|
|---|
| 146 | break;
|
|---|
| 147 | if ( memcmp(m, submem, sublen) == 0 )
|
|---|
| 148 | return (void *)m;
|
|---|
| 149 | }
|
|---|
| 150 |
|
|---|
| 151 | return NULL;
|
|---|
| 152 | }
|
|---|
| 153 |
|
|---|
| 154 | static void resolve_farptr( uint32 *string_farptr )
|
|---|
| 155 | {
|
|---|
| 156 | if ( (*string_farptr >> 16) == sel_infoblock && (*string_farptr &= 0xffff) < sizeof(vesa3_infoblock) )
|
|---|
| 157 | *string_farptr += (uint32)&infoblock;
|
|---|
| 158 | else
|
|---|
| 159 | *string_farptr = 0;
|
|---|
| 160 | }
|
|---|
| 161 |
|
|---|
| 162 | //----------------------------------------------------------------------------
|
|---|
| 163 |
|
|---|
| 164 | static uint16 vesa3_get_mode_infoblock( uint16 mode )
|
|---|
| 165 | {
|
|---|
| 166 | struct s_regs regs;
|
|---|
| 167 |
|
|---|
| 168 | regs.ax = 0x4f01;
|
|---|
| 169 | regs.cx = mode;
|
|---|
| 170 | regs.es = i386_selector_add( SELECTOR(&mode_infoblock,sizeof(mode_infoblock)-1,DATA_w,false) );
|
|---|
| 171 | regs.di = 0;
|
|---|
| 172 | vesa_call( ®s );
|
|---|
| 173 | i386_selector_remove( regs.es );
|
|---|
| 174 |
|
|---|
| 175 | return regs.ax;
|
|---|
| 176 | }
|
|---|
| 177 |
|
|---|
| 178 | static uint16 vesa3_set_mode_CRTC_generic( uint16 mode, vesa3_CRTC_infoblock *crtc )
|
|---|
| 179 | {
|
|---|
| 180 | /* vesa3_CRTC_infoblock CRTC_info_block = {
|
|---|
| 181 | 640+16+64+80, 640+16, 640+16+64,
|
|---|
| 182 | 480+3+4+13, 480+3, 480+3+4,
|
|---|
| 183 | VESA3_CRTC_HSYNC_NEGATIVE, 23750000, 5938, {} };*/
|
|---|
| 184 | struct s_regs regs;
|
|---|
| 185 |
|
|---|
| 186 | regs.ax = 0x4f02;
|
|---|
| 187 | regs.bx = mode | 0xc000; //| 0xc800;
|
|---|
| 188 | regs.es = 0;
|
|---|
| 189 | /* regs.es = i386_selector_add( SELECTOR(&CRTC_info_block,sizeof(CRTC_info_block)-1,DATA_w,false) );
|
|---|
| 190 | regs.di = 0;*/
|
|---|
| 191 | vesa_call( ®s );
|
|---|
| 192 |
|
|---|
| 193 | return regs.ax;
|
|---|
| 194 | }
|
|---|
| 195 |
|
|---|
| 196 | struct s_edid {
|
|---|
| 197 | uint16 dot_clock; // pixel clock / 10000
|
|---|
| 198 | uint8 xres_lo;
|
|---|
| 199 | uint16 hblank : 12; // blank = front porch + sync width + back porch
|
|---|
| 200 | uint8 xres_hi : 4;
|
|---|
| 201 | uint8 yres_lo;
|
|---|
| 202 | uint16 vblank : 12;
|
|---|
| 203 | uint8 yres_hi : 4;
|
|---|
| 204 | uint8 hoverplus_lo; // overplus = front porch
|
|---|
| 205 | uint8 hsyncwidth_lo;
|
|---|
| 206 | uint8 vsyncwidth_lo : 4;
|
|---|
| 207 | uint8 voverplus_lo : 4;
|
|---|
| 208 | uint8 vsyncwidth_hi : 2;
|
|---|
| 209 | uint8 voverplus_hi : 2;
|
|---|
| 210 | uint8 hsyncwidth_hi : 2;
|
|---|
| 211 | uint8 hoverplus_hi : 2;
|
|---|
| 212 | uint8 _reserved[6];
|
|---|
| 213 | } _PACKED;
|
|---|
| 214 |
|
|---|
| 215 | static struct s_edid *ati_edid_dest;
|
|---|
| 216 |
|
|---|
| 217 | static uint16 vesa3_set_mode_CRTC_ATI( uint16 mode, vesa3_CRTC_infoblock *crtc )
|
|---|
| 218 | {
|
|---|
| 219 | /* static const struct s_edid default_edid = {
|
|---|
| 220 | 2375, 640&0xff, 160, 640>>8, 480&0xff, 20, 480>>8,
|
|---|
| 221 | 16&0xff, 64&0xff, 4, 3&0xff, 4>>4, 3>>4, 64>>8, 16>>8, {}
|
|---|
| 222 | };*/
|
|---|
| 223 | struct s_regs regs;
|
|---|
| 224 | unsigned hoverplus = crtc->horizontal_sync_start - mode_infoblock.x_resolution;
|
|---|
| 225 | unsigned voverplus = crtc->vertical_sync_start - mode_infoblock.y_resolution;
|
|---|
| 226 | unsigned hsyncwidth = crtc->horizontal_sync_end - crtc->horizontal_sync_start;
|
|---|
| 227 | unsigned vsyncwidth = crtc->vertical_sync_end - crtc->vertical_sync_start;
|
|---|
| 228 |
|
|---|
| 229 | dprintf( "vesa3: ATI: writing EDID data\n" );
|
|---|
| 230 |
|
|---|
| 231 | ati_edid_dest->dot_clock = crtc->pixel_clock / 10000;
|
|---|
| 232 | ati_edid_dest->xres_lo = mode_infoblock.x_resolution & 0xff;
|
|---|
| 233 | ati_edid_dest->hblank = crtc->horizontal_total - mode_infoblock.x_resolution;
|
|---|
| 234 | ati_edid_dest->xres_hi = mode_infoblock.x_resolution >> 8;
|
|---|
| 235 | ati_edid_dest->yres_lo = mode_infoblock.y_resolution & 0xff;
|
|---|
| 236 | ati_edid_dest->vblank = crtc->vertical_total - mode_infoblock.y_resolution;
|
|---|
| 237 | ati_edid_dest->yres_hi = mode_infoblock.y_resolution >> 8;
|
|---|
| 238 | ati_edid_dest->hoverplus_lo = hoverplus & 0xff;
|
|---|
| 239 | ati_edid_dest->hsyncwidth_lo = hsyncwidth & 0xff;
|
|---|
| 240 | ati_edid_dest->vsyncwidth_lo = vsyncwidth & 0xf;
|
|---|
| 241 | ati_edid_dest->voverplus_lo = voverplus & 0xf;
|
|---|
| 242 | ati_edid_dest->vsyncwidth_hi = vsyncwidth >> 4;
|
|---|
| 243 | ati_edid_dest->voverplus_hi = voverplus >> 4;
|
|---|
| 244 | ati_edid_dest->hsyncwidth_hi = hsyncwidth >> 8;
|
|---|
| 245 | ati_edid_dest->hoverplus_hi = hoverplus >> 8;
|
|---|
| 246 |
|
|---|
| 247 | // memcpy( ati_edid_dest, &default_edid, sizeof(struct s_edid) );
|
|---|
| 248 | // memcpy( &video_bios[0x9b8e], &video_bios[0x9f26+9*0x12], 0x12 );
|
|---|
| 249 |
|
|---|
| 250 | dprintf( "vesa3: ATI: EDID: dot_clock %u, xres %u, yres %u, hblank %u, vblank %u, hsyncwidth %u, vsyncwidth %u, hoverplus %u, voverplus %u\n",
|
|---|
| 251 | ati_edid_dest->dot_clock,
|
|---|
| 252 | ati_edid_dest->xres_lo+(ati_edid_dest->xres_hi<<8),
|
|---|
| 253 | ati_edid_dest->yres_lo+(ati_edid_dest->yres_hi<<8),
|
|---|
| 254 | ati_edid_dest->hblank,
|
|---|
| 255 | ati_edid_dest->vblank,
|
|---|
| 256 | ati_edid_dest->hsyncwidth_lo+(ati_edid_dest->hsyncwidth_hi<<8),
|
|---|
| 257 | ati_edid_dest->vsyncwidth_lo+(ati_edid_dest->vsyncwidth_hi<<4),
|
|---|
| 258 | ati_edid_dest->hoverplus_lo+(ati_edid_dest->hoverplus_hi<<8),
|
|---|
| 259 | ati_edid_dest->voverplus_lo+(ati_edid_dest->voverplus_hi<<4)
|
|---|
| 260 | );
|
|---|
| 261 |
|
|---|
| 262 | regs.ax = 0x4f02;
|
|---|
| 263 | regs.bx = mode | 0xc000;
|
|---|
| 264 | regs.es = 0;
|
|---|
| 265 | vesa_call( ®s );
|
|---|
| 266 |
|
|---|
| 267 | return regs.ax;
|
|---|
| 268 | }
|
|---|
| 269 |
|
|---|
| 270 | static uint16 vesa3_set_mode_CRTC_nVidia( uint16 mode, vesa3_CRTC_infoblock *crtc )
|
|---|
| 271 | {
|
|---|
| 272 | struct s_regs regs;
|
|---|
| 273 |
|
|---|
| 274 | regs.ax = 0x4f02;
|
|---|
| 275 | regs.bx = mode | 0xc000;
|
|---|
| 276 | regs.di = 0;
|
|---|
| 277 | regs.es = 0;
|
|---|
| 278 | vesa_call( ®s );
|
|---|
| 279 |
|
|---|
| 280 | return regs.ax;
|
|---|
| 281 | }
|
|---|
| 282 |
|
|---|
| 283 | static uint16 (*vesa3_set_mode_CRTC)(uint16, vesa3_CRTC_infoblock *) = vesa3_set_mode_CRTC_generic;
|
|---|
| 284 |
|
|---|
| 285 | static uint16 vesa3_set_mode( unsigned int xres, unsigned int yres, unsigned int bpp, unsigned int refresh_rate )
|
|---|
| 286 | {
|
|---|
| 287 | uint16 err = 0xffff;
|
|---|
| 288 | uint16 *mode = (uint16 *)infoblock.video_mode_ptr;
|
|---|
| 289 |
|
|---|
| 290 | if ( mode ) {
|
|---|
| 291 | dprintf( "vesa3: searching mode %ux%ux%u...\n", xres, yres, bpp );
|
|---|
| 292 | while ( *mode != 0xffff ) {
|
|---|
| 293 | err = vesa3_get_mode_infoblock( *mode );
|
|---|
| 294 | if ( err == 0x004f
|
|---|
| 295 | && mode_infoblock.x_resolution == xres
|
|---|
| 296 | && mode_infoblock.y_resolution == yres
|
|---|
| 297 | && mode_infoblock.bits_per_pixel == bpp ) {
|
|---|
| 298 | struct vesa3_CRTC_infoblock crtc;
|
|---|
| 299 | gtf_compute_CRTC_data( &crtc, xres, yres, refresh_rate<<10, false, false );
|
|---|
| 300 | if ( crtc.pixel_clock > mode_infoblock.max_pixel_clock && mode_infoblock.max_pixel_clock > 0 ) {
|
|---|
| 301 | dprintf( "vesa3: pixel clock too high (max. is %u Hz)!\n", mode_infoblock.max_pixel_clock );
|
|---|
| 302 | return -1;
|
|---|
| 303 | }
|
|---|
| 304 | dprintf( "vesa3: switching to video mode 0x%x...\n", *mode );
|
|---|
| 305 | err = vesa3_set_mode_CRTC( *mode, &crtc );
|
|---|
| 306 | break;
|
|---|
| 307 | }
|
|---|
| 308 | mode++;
|
|---|
| 309 | }
|
|---|
| 310 | }
|
|---|
| 311 |
|
|---|
| 312 | return err;
|
|---|
| 313 | }
|
|---|
| 314 |
|
|---|
| 315 | //----------------------------------------------------------------------------
|
|---|
| 316 | /* For compatibility with the vesa (2.0) driver and demonstration purposes
|
|---|
| 317 | this driver goes to VESA VBE mode 640x480x32/15 when opened.
|
|---|
| 318 | Note that for going back to text mode you have to utilize a standard VGA
|
|---|
| 319 | driver as VESA VBE 3.0 does NOT support text modes.
|
|---|
| 320 | */
|
|---|
| 321 | static int vesa3_open( dev_ident ident, dev_cookie *cookie )
|
|---|
| 322 | {
|
|---|
| 323 | int err = vesa3_set_mode( 640, 480, 32, 60 );
|
|---|
| 324 |
|
|---|
| 325 | dprintf( "vesa3: open(): vesa3_set_mode() returned 0x%x\n", err );
|
|---|
| 326 |
|
|---|
| 327 | if ( err != 0x004f ) {
|
|---|
| 328 | err = vesa3_set_mode( 640, 480, 15, 60 ); // let's try 15 bit mode instead
|
|---|
| 329 | dprintf( "vesa3: open(): vesa3_set_mode() returned 0x%x\n", err );
|
|---|
| 330 | if ( err != 0x004f )
|
|---|
| 331 | return ERR_GENERAL;
|
|---|
| 332 | }
|
|---|
| 333 |
|
|---|
| 334 | dprintf( "vesa3: physical video memory at 0x%x\n", mode_infoblock.phys_base_ptr );
|
|---|
| 335 |
|
|---|
| 336 | fb_info.width = mode_infoblock.x_resolution;
|
|---|
| 337 | fb_info.height = mode_infoblock.y_resolution;
|
|---|
| 338 | fb_info.bit_depth = mode_infoblock.bits_per_pixel;
|
|---|
| 339 | switch ( fb_info.bit_depth ) {
|
|---|
| 340 | case 8: fb_info.color_space = COLOR_SPACE_8BIT; break;
|
|---|
| 341 | case 15: fb_info.color_space = COLOR_SPACE_RGB555; break;
|
|---|
| 342 | case 24: fb_info.color_space = COLOR_SPACE_RGB888; break;
|
|---|
| 343 | case 32: fb_info.color_space = COLOR_SPACE_RGB888+1; // COLOR_SPACE_RGB8888
|
|---|
| 344 | }
|
|---|
| 345 |
|
|---|
| 346 | #if 0
|
|---|
| 347 | {
|
|---|
| 348 | unsigned i, x, y, rgb1, rgb2;
|
|---|
| 349 | void *video_mem;
|
|---|
| 350 |
|
|---|
| 351 | //draw a color-fading rectangle on screen
|
|---|
| 352 | vm_map_physical_memory( vm_get_kernel_aspace_id(), "linear_video_mem", (void**)&video_mem, REGION_ADDR_ANY_ADDRESS,
|
|---|
| 353 | mode_infoblock.x_resolution * mode_infoblock.y_resolution * ((mode_infoblock.bits_per_pixel+7)/8),
|
|---|
| 354 | LOCK_RW | LOCK_KERNEL, (addr_t)mode_infoblock.phys_base_ptr );
|
|---|
| 355 |
|
|---|
| 356 | #define PIXEL8888(x,y,c) \
|
|---|
| 357 | *(uint32*)&((char*)video_mem)[((y)*640+(x))*4] = (c);
|
|---|
| 358 |
|
|---|
| 359 | #define PIXEL888(x,y,c) \
|
|---|
| 360 | *(uint16*)&((char*)video_mem)[((y)*640+(x))*3] = (c)&0xffff; \
|
|---|
| 361 | *(uint8*)&((char*)video_mem)[((y)*640+(x))*3+2] = (c)>>16;
|
|---|
| 362 |
|
|---|
| 363 | #define PIXEL555(x,y,c) \
|
|---|
| 364 | ((uint16*)video_mem)[((y)*640+(x))] = (((c)>>3)&0x1f) | (((c)>>6)&0x3e0) | (((c)>>9)&0x7c00);
|
|---|
| 365 |
|
|---|
| 366 | #define PIXEL PIXEL8888
|
|---|
| 367 |
|
|---|
| 368 | #if 1
|
|---|
| 369 | for ( i = 0; i < 20; i++ ) {
|
|---|
| 370 | for ( x = 0; x < 640*480; x++ ) {
|
|---|
| 371 | if ( (x/640)%30 < 10 ) {
|
|---|
| 372 | PIXEL( x, 0, 0xff*(640-(x+i))/640 + ((0xff*(x+i)/640) << 8) );
|
|---|
| 373 | }
|
|---|
| 374 | else if ( (x/640)%30 < 20 ) {
|
|---|
| 375 | PIXEL( x, 0, ((0xff*(640-(x+i))/640) << 8) + ((0xff*(x+i)/640) << 16) );
|
|---|
| 376 | }
|
|---|
| 377 | else {
|
|---|
| 378 | PIXEL( x, 0, ((0xff*(640-(x+i))/640) << 16) + 0xff*(x+i)/640 );
|
|---|
| 379 | }
|
|---|
| 380 | }
|
|---|
| 381 | /* for ( y = 0; y < 256; y++ ) {
|
|---|
| 382 | rgb1 = ((255-y)<<8)+(y<<16);
|
|---|
| 383 | rgb2 = ((y*(i&255)>>8)<<16)+((y*(i&255)>>8)<<8)+(255-y)+(y*(i&255)>>8);
|
|---|
| 384 | for ( x = 0; x < 256; x++ )
|
|---|
| 385 | ((unsigned*)video_mem)[y*640+x] =
|
|---|
| 386 | (((rgb1&0xff)*(255-x)>>8)+((rgb2&0xff)*x)>>8) |
|
|---|
| 387 | ((((((rgb1&0xff00)>>8)*(255-x)>>8)+(((rgb2&0xff00)>>8)*x>>8)))<<8) |
|
|---|
| 388 | (((((rgb1>>16)*(255-x)>>8)+((rgb2>>16)*x>>8)))<<16);
|
|---|
| 389 | }*/
|
|---|
| 390 | for ( x = 0; x < 1<<20; x++ ) y++; // dummy loop
|
|---|
| 391 | }
|
|---|
| 392 | #endif
|
|---|
| 393 | for ( y = 0; y < 20; y++ )
|
|---|
| 394 | for ( x = 0; x < 20; x++ )
|
|---|
| 395 | PIXEL( x, y, 0x1f );
|
|---|
| 396 | }
|
|---|
| 397 | #endif
|
|---|
| 398 |
|
|---|
| 399 | return NO_ERROR;
|
|---|
| 400 | }
|
|---|
| 401 |
|
|---|
| 402 | //----------------------------------------------------------------------------
|
|---|
| 403 | static int vesa3_close( dev_cookie cookie )
|
|---|
| 404 | {
|
|---|
| 405 | return NO_ERROR;
|
|---|
| 406 | }
|
|---|
| 407 |
|
|---|
| 408 | //----------------------------------------------------------------------------
|
|---|
| 409 | static int vesa3_free_cookie( dev_cookie cookie )
|
|---|
| 410 | {
|
|---|
| 411 | return NO_ERROR;
|
|---|
| 412 | }
|
|---|
| 413 |
|
|---|
| 414 | //----------------------------------------------------------------------------
|
|---|
| 415 | static int vesa3_seek( dev_cookie cookie, off_t pos, seek_type st)
|
|---|
| 416 | {
|
|---|
| 417 | return ERR_NOT_ALLOWED;
|
|---|
| 418 | }
|
|---|
| 419 |
|
|---|
| 420 | //----------------------------------------------------------------------------
|
|---|
| 421 | static int vesa3_ioctl( dev_cookie cookie, int op, void *buf, size_t len )
|
|---|
| 422 | {
|
|---|
| 423 | int err = ERR_INVALID_ARGS;
|
|---|
| 424 |
|
|---|
| 425 | switch ( op ) {
|
|---|
| 426 |
|
|---|
| 427 | case 0xfb:
|
|---|
| 428 | err = user_memcpy( buf, &mode_infoblock.phys_base_ptr, 4 );
|
|---|
| 429 | break;
|
|---|
| 430 |
|
|---|
| 431 | case IOCTL_DEVFS_GET_FRAMEBUFFER_INFO:
|
|---|
| 432 | dprintf( "vesa3: IOCTL_DEVFS_GET_FRAMEBUFFER_INFO\n" );
|
|---|
| 433 |
|
|---|
| 434 | if ( is_kernel_address(buf) )
|
|---|
| 435 | return ERR_VM_BAD_USER_MEMORY;
|
|---|
| 436 |
|
|---|
| 437 | if ( len == sizeof(fb_info) )
|
|---|
| 438 | err = user_memcpy( buf, &fb_info, sizeof(fb_info) );
|
|---|
| 439 | break;
|
|---|
| 440 |
|
|---|
| 441 | case IOCTL_DEVFS_MAP_FRAMEBUFFER:
|
|---|
| 442 | {
|
|---|
| 443 | aspace_id aid = vm_get_current_user_aspace_id();
|
|---|
| 444 | region_id rid;
|
|---|
| 445 | void *linear_video_mem;
|
|---|
| 446 |
|
|---|
| 447 | dprintf( "vesa3: IOCTL_DEVFS_MAP_FRAMEBUFFER\n" );
|
|---|
| 448 |
|
|---|
| 449 | if ( is_kernel_address(buf) )
|
|---|
| 450 | return ERR_VM_BAD_USER_MEMORY;
|
|---|
| 451 |
|
|---|
| 452 | if ( len != sizeof(linear_video_mem) )
|
|---|
| 453 | break;
|
|---|
| 454 |
|
|---|
| 455 | err = rid = vm_map_physical_memory( aid, "linear_video_mem", &linear_video_mem, REGION_ADDR_ANY_ADDRESS,
|
|---|
| 456 | mode_infoblock.x_resolution * mode_infoblock.y_resolution * ((mode_infoblock.bits_per_pixel+7)/8),
|
|---|
| 457 | LOCK_RW, (addr_t)mode_infoblock.phys_base_ptr );
|
|---|
| 458 | if ( err < 0 )
|
|---|
| 459 | break;
|
|---|
| 460 |
|
|---|
| 461 | err = user_memcpy( buf, &linear_video_mem, sizeof(linear_video_mem) );
|
|---|
| 462 | if ( err < 0 ) {
|
|---|
| 463 | vm_delete_region( aid, rid );
|
|---|
| 464 | break;
|
|---|
| 465 | }
|
|---|
| 466 |
|
|---|
| 467 | err = rid; // return region id
|
|---|
| 468 | }
|
|---|
| 469 | }
|
|---|
| 470 |
|
|---|
| 471 | dprintf( "vesa3: ioctl returns 0x%x\n", err );
|
|---|
| 472 |
|
|---|
| 473 | return err;
|
|---|
| 474 | }
|
|---|
| 475 |
|
|---|
| 476 | //----------------------------------------------------------------------------
|
|---|
| 477 | static ssize_t vesa3_read( dev_cookie cookie, void *buf, off_t pos, ssize_t len )
|
|---|
| 478 | {
|
|---|
| 479 | return ERR_UNIMPLEMENTED;
|
|---|
| 480 | }
|
|---|
| 481 |
|
|---|
| 482 | //----------------------------------------------------------------------------
|
|---|
| 483 | static ssize_t vesa3_write( dev_cookie cookie, const void *buf, off_t pos, ssize_t len )
|
|---|
| 484 | {
|
|---|
| 485 | return ERR_UNIMPLEMENTED;
|
|---|
| 486 | }
|
|---|
| 487 |
|
|---|
| 488 | //----------------------------------------------------------------------------
|
|---|
| 489 | static struct dev_calls vesa3_hooks = {
|
|---|
| 490 | vesa3_open,
|
|---|
| 491 | vesa3_close,
|
|---|
| 492 | vesa3_free_cookie,
|
|---|
| 493 | vesa3_seek,
|
|---|
| 494 | vesa3_ioctl,
|
|---|
| 495 | vesa3_read,
|
|---|
| 496 | vesa3_write,
|
|---|
| 497 | /* no paging here */
|
|---|
| 498 | NULL,
|
|---|
| 499 | NULL,
|
|---|
| 500 | NULL
|
|---|
| 501 | };
|
|---|
| 502 |
|
|---|
| 503 | //----------------------------------------------------------------------------
|
|---|
| 504 | int dev_bootstrap(void);
|
|---|
| 505 |
|
|---|
| 506 | int dev_bootstrap(void)
|
|---|
| 507 | {
|
|---|
| 508 | struct s_regs regs;
|
|---|
| 509 | struct vesa3_pm_infoblock *pm_info;
|
|---|
| 510 | unsigned char *ptr;
|
|---|
| 511 | unsigned char checksum = 0;
|
|---|
| 512 | unsigned int i;
|
|---|
| 513 | enum { BIOS_ANY, BIOS_NVIDIA, BIOS_ATI } bios_vendor = BIOS_ANY;
|
|---|
| 514 | int vesa_data_size = VESA_DATA_SIZE;
|
|---|
| 515 | region_id id;
|
|---|
| 516 | aspace_id sp = vm_get_kernel_aspace_id();
|
|---|
| 517 | unsigned char *video_mem;
|
|---|
| 518 | int ret_val;
|
|---|
| 519 |
|
|---|
| 520 | dprintf( "vesa3: setting up VBE 3.0...\n" );
|
|---|
| 521 |
|
|---|
| 522 | // copy video BIOS to RAM
|
|---|
| 523 | video_bios = (unsigned char *)kmalloc( VESA_CODE_SIZE );
|
|---|
| 524 | if ( video_bios == NULL )
|
|---|
| 525 | return ERR_NO_MEMORY;
|
|---|
| 526 |
|
|---|
| 527 | #ifdef FAKE_VESA
|
|---|
| 528 | memcpy( video_bios, biosdata, sizeof(biosdata) );
|
|---|
| 529 | #else
|
|---|
| 530 | ret_val = vm_map_physical_memory( sp, "video_bios", (void**)&ptr,
|
|---|
| 531 | REGION_ADDR_ANY_ADDRESS, VESA_CODE_SIZE, LOCK_RO | LOCK_KERNEL, (addr_t)0xc0000 );
|
|---|
| 532 | if ( ret_val < 0 )
|
|---|
| 533 | goto no_vesa1;
|
|---|
| 534 |
|
|---|
| 535 | memcpy( video_bios, ptr, VESA_CODE_SIZE );
|
|---|
| 536 |
|
|---|
| 537 | vm_delete_region( sp, ret_val );
|
|---|
| 538 | #endif
|
|---|
| 539 |
|
|---|
| 540 | // find VESA VBE protected mode info block signature
|
|---|
| 541 | ptr = video_bios;
|
|---|
| 542 | while ( ptr <= video_bios+VESA_CODE_SIZE-sizeof(struct vesa3_pm_infoblock) && ((struct vesa3_pm_infoblock*)ptr)->signature != VESA_MAGIC )
|
|---|
| 543 | ptr++;
|
|---|
| 544 |
|
|---|
| 545 | pm_info = (struct vesa3_pm_infoblock*)ptr;
|
|---|
| 546 |
|
|---|
| 547 | ret_val = ERR_GENERAL;
|
|---|
| 548 | if ( pm_info->signature != VESA_MAGIC ) {
|
|---|
| 549 | dprintf( "vesa3: VBE 3.0 not available!\n" );
|
|---|
| 550 | goto no_vesa1;
|
|---|
| 551 | }
|
|---|
| 552 |
|
|---|
| 553 | dprintf( "vesa3: VBE 3.0 protected mode info block found...\n" );
|
|---|
| 554 |
|
|---|
| 555 | // calculate checksum
|
|---|
| 556 | for ( i = 0; i < sizeof(struct vesa3_pm_infoblock); i++ )
|
|---|
| 557 | checksum += *ptr++;
|
|---|
| 558 |
|
|---|
| 559 | if ( checksum == 0 )
|
|---|
| 560 | dprintf( "vesa3: checksum ok...\n" );
|
|---|
| 561 | else {
|
|---|
| 562 | // find out if we have a broken ATI BIOS
|
|---|
| 563 | static const char *const ati_vendor = "ATI Technologies Inc.";
|
|---|
| 564 | /* static const char edid_640x480x60[18] = {
|
|---|
| 565 | 0xd6,0x09,0x80,0xa0,0x20,0xe0,0x2d,0x10,0x10,0x60,0xa2,0x00,0x00,0x00,0x00,0x08,0x08,0x18
|
|---|
| 566 | };*/
|
|---|
| 567 |
|
|---|
| 568 | ptr = memmem( video_bios, VESA_CODE_SIZE, ati_vendor, strlen(ati_vendor) );
|
|---|
| 569 | if ( ptr != NULL ) {
|
|---|
| 570 | dprintf( "vesa3: ATI: checksum wrong, but broken ATI BIOS detected... trying to fix it...\n" );
|
|---|
| 571 | bios_vendor = BIOS_ATI;
|
|---|
| 572 | vesa3_set_mode_CRTC = vesa3_set_mode_CRTC_ATI;
|
|---|
| 573 |
|
|---|
| 574 | /* // find EDID source data
|
|---|
| 575 | ptr = memmem( video_bios, VESA_CODE_SIZE, edid_640x480x60, sizeof(edid_640x480x60) );
|
|---|
| 576 | if ( ptr == NULL ) {
|
|---|
| 577 | dprintf( "vesa3: ATI: could not find EDID data in BIOS!\n" );
|
|---|
| 578 | goto no_vesa1;
|
|---|
| 579 | }
|
|---|
| 580 | dprintf( "vesa3: ATI: EDID data found at 0x%x\n", ptr-video_bios );*/
|
|---|
| 581 |
|
|---|
| 582 | // find EDID destination block
|
|---|
| 583 | i = *(uint16*)&video_bios[*(uint16*)&video_bios[*(uint16*)&video_bios[0x48]+0x34]+0x2];
|
|---|
| 584 | dprintf( "vesa3: ATI: EDID destination at 0x%x\n", i );
|
|---|
| 585 | ati_edid_dest = (struct s_edid *)&video_bios[i];
|
|---|
| 586 |
|
|---|
| 587 | //*(uint16*)(&video_bios[6]) = pm_info->sel_code;
|
|---|
| 588 | *(uint32*)(&video_bios[4]) = 0;
|
|---|
| 589 | }
|
|---|
| 590 | else {
|
|---|
| 591 | dprintf( "vesa3: checksum wrong!\n" );
|
|---|
| 592 | goto no_vesa1;
|
|---|
| 593 | }
|
|---|
| 594 | }
|
|---|
| 595 |
|
|---|
| 596 | // VBE 3.0 pm block found!
|
|---|
| 597 |
|
|---|
| 598 | // we start with the init function
|
|---|
| 599 | retn = pm_info->init_offs;
|
|---|
| 600 |
|
|---|
| 601 | // now analyze the bios to find out if it is a nVidia derived broken one
|
|---|
| 602 | if ( video_bios[retn] == 0xe9 ) { // jmp
|
|---|
| 603 | ptr = (unsigned char*)(video_bios+retn+3) + *(uint16*)&(video_bios[retn+1]);
|
|---|
| 604 | // look for "mov ds,[cs:0x6e]; call ?; mov ax,[cs:0x66]"
|
|---|
| 605 | if ( *(uint32*)ptr == 0x6e1e8e2e && *(uint16*)(ptr+4) == 0xe800 && *(uint32*)(ptr+8) == 0x0066a12e ) {
|
|---|
| 606 | // look for "o32 retn" (broken bios) or "retf" (repaired bios)
|
|---|
| 607 | ptr += 12;
|
|---|
| 608 | while ( ptr <= video_bios+0x8000-2 && *ptr != 0xcb && *(uint16*)ptr != 0xc366 )
|
|---|
| 609 | ptr++;
|
|---|
| 610 | // ok, this bios is quite certainly broken, so we patch it
|
|---|
| 611 | if ( *(uint16*)ptr == 0xc366 ) {
|
|---|
| 612 | dprintf( "vesa3: nVidia: detected broken nVidia BIOS... trying to fix it...\n" );
|
|---|
| 613 | bios_vendor = BIOS_NVIDIA;
|
|---|
| 614 | vesa3_set_mode_CRTC = vesa3_set_mode_CRTC_nVidia;
|
|---|
| 615 | vesa_data_size += 0x800; // account for copy of bios video tables
|
|---|
| 616 | // we can't call directly so we write a stub code
|
|---|
| 617 | // at the end of the bios code
|
|---|
| 618 | ptr = video_bios+0xf000;
|
|---|
| 619 | dprintf( "vesa3: nVidia: creating stub code at %x...\n", (int)ptr );
|
|---|
| 620 | *((uint16*)ptr)++ = 0xbe66; // mov esi,retn
|
|---|
| 621 | *((int32*)ptr)++ = (int32)&retn;
|
|---|
| 622 | *((uint32*)ptr)++ = 0x68368b67; // mov si,[esi]
|
|---|
| 623 | *((uint16*)ptr)++ = 0x0000; // push 0
|
|---|
| 624 | *((uint32*)ptr)++ = 0xcb66d6ff; // call si; o32 retf
|
|---|
| 625 | // the other places we need to fix is where they try to load
|
|---|
| 626 | // the video parameter tables at address 0x4a8
|
|---|
| 627 | for ( ptr = video_bios+0x5b; ptr <= video_bios+0x8000-10; ptr++ )
|
|---|
| 628 | // these are either "les ?,[es:?...]"
|
|---|
| 629 | if ( *((uint16*)ptr) == 0xc426 ) {
|
|---|
| 630 | // sub bx,bx; mov es,bx; les bx,[es:0x4a8]; les bx,[es:bx+0x10]; les bx,[es:bx+0x16]
|
|---|
| 631 | // -> sub bx,bx; mov es,bx; 13 x nop;
|
|---|
| 632 | if ( *(uint32*)(ptr-4) == 0xc38edb2b
|
|---|
| 633 | && *(uint32*)(ptr+1) == 0x04a81ec4
|
|---|
| 634 | && *(uint32*)(ptr+5) == 0x105fc426
|
|---|
| 635 | && *(uint32*)(ptr+9) == 0x165fc426 ) {
|
|---|
| 636 | dprintf( "vesa3: patching %x...\n", (int)ptr );
|
|---|
| 637 | for ( i = 0; i < 13; i++ ) *ptr++ = 0x90;
|
|---|
| 638 | }
|
|---|
| 639 | /* else if ( *(uint32*)(ptr-4) == 0x04a83ec4 ) {
|
|---|
| 640 | // les di,[0x4a8]; les di,[es:di]
|
|---|
| 641 | // -> push ds; pop es; mov di,0x600; nop; nop
|
|---|
| 642 | if ( *(ptr+2) == 0x3d ) {
|
|---|
| 643 | dprintf( "vesa3: patching %x...\n", (int)(ptr-4) );
|
|---|
| 644 | *(uint32*)(ptr-4) = 0x00bf071e;
|
|---|
| 645 | *(uint16*)ptr = 0x9006;
|
|---|
| 646 | *(ptr+2) = 0x90;
|
|---|
| 647 | }
|
|---|
| 648 | // les di,[0x4a8]; les di,[es:di+0x10] || les di,[es:di+0x4]
|
|---|
| 649 | // -> xor di,di; mov es,di; 4 x nop;
|
|---|
| 650 | else if ( *(uint16*)(ptr+2) == 0x107d || *(uint16*)(ptr+2) == 0x047d ) {
|
|---|
| 651 | dprintf( "vesa3: patching %x...\n", (int)(ptr-4) );
|
|---|
| 652 | *(uint32*)(ptr-4) = 0xc78eff31;
|
|---|
| 653 | *(uint32*)ptr = 0x90909090;
|
|---|
| 654 | }
|
|---|
| 655 | }*/
|
|---|
| 656 | }
|
|---|
| 657 | /* // or "lds si,[0x4a8]; lds si,[si]"
|
|---|
| 658 | // -> mov esi,0x600
|
|---|
| 659 | else if ( *(uint32*)ptr == 0x04a836c5 && *(uint16*)(ptr+4) == 0x34c5 ) {
|
|---|
| 660 | dprintf( "vesa3: patching %x...\n", (int)ptr );
|
|---|
| 661 | *(uint32*)ptr = 0x0600be66;
|
|---|
| 662 | *(uint16*)(ptr+4) = 0x0000;
|
|---|
| 663 | }*/
|
|---|
| 664 | }
|
|---|
| 665 | }
|
|---|
| 666 | }
|
|---|
| 667 |
|
|---|
| 668 | // setup structure (provide selectors, map video mem, ...)
|
|---|
| 669 | ret_val = ERR_NO_MEMORY;
|
|---|
| 670 | bios_data = (char *)kmalloc( vesa_data_size );
|
|---|
| 671 | if ( bios_data == NULL )
|
|---|
| 672 | goto no_vesa1;
|
|---|
| 673 | bios_stack = (char *)kmalloc( VESA_STACK_SIZE );
|
|---|
| 674 | if ( bios_stack == NULL )
|
|---|
| 675 | goto no_vesa2;
|
|---|
| 676 | memset( bios_data, 0, VESA_DATA_SIZE );
|
|---|
| 677 |
|
|---|
| 678 | pm_info->sel_bios_data = i386_selector_add( SELECTOR(bios_data,vesa_data_size-1,DATA_w,false) );
|
|---|
| 679 | pm_info->sel_code = i386_selector_add( SELECTOR(video_bios,VESA_CODE_SIZE-1,DATA_w,false) );
|
|---|
| 680 |
|
|---|
| 681 | sel_code = i386_selector_add( SELECTOR(video_bios,VESA_CODE_SIZE-1,CODE_r,false) );
|
|---|
| 682 | sel_stack = i386_selector_add( SELECTOR(bios_stack,VESA_STACK_SIZE-1,DATA_w,false) );
|
|---|
| 683 |
|
|---|
| 684 | if ( bios_vendor == BIOS_NVIDIA ) {
|
|---|
| 685 | farcall.offset = 0xf000;
|
|---|
| 686 | farcall.seg = sel_code;
|
|---|
| 687 | #if 0
|
|---|
| 688 | // copy video tables to local memory
|
|---|
| 689 | ret_val = vm_map_physical_memory( sp, "video_tables", (void**)&ptr,
|
|---|
| 690 | REGION_ADDR_ANY_ADDRESS, 0x100000, LOCK_RW | LOCK_KERNEL, (addr_t)0x0 );
|
|---|
| 691 | if ( ret_val < 0 )
|
|---|
| 692 | goto no_vesa3;
|
|---|
| 693 | dprintf("vesa3: nVidia: (int)linear(ptr+0x4a8) = 0x%x\n", (int)linear(ptr+0x4a8) );
|
|---|
| 694 | memcpy( bios_data+VESA_DATA_SIZE, ptr+(int)linear(ptr+(int)linear(ptr+0x4a8)), 29*64 ); // video parameter table
|
|---|
| 695 | vm_delete_region( sp, ret_val );
|
|---|
| 696 | #else
|
|---|
| 697 | dprintf( "vesa3: nVidia: setting up fake video parameter table...\n" );
|
|---|
| 698 | memcpy( bios_data+VESA_DATA_SIZE, video_param_table, 29*64 ); // VGA video parameter table
|
|---|
| 699 | ptr = bios_data+VESA_DATA_SIZE+29*64; // video save pointer table
|
|---|
| 700 | memset( ptr, 0, 0x1c ); // make sure it is zeroed out
|
|---|
| 701 | *(uint16 *)ptr = VESA_DATA_SIZE; // first entry is pointer to video parameter table
|
|---|
| 702 | *(uint16 *)(ptr+2) = pm_info->sel_bios_data;
|
|---|
| 703 | *(uint16*)(bios_data+0x4a8) = VESA_DATA_SIZE+29*64; // 0x4a8 is pointer to video save pointer table
|
|---|
| 704 | *(uint16*)(bios_data+0x4a8+2) = pm_info->sel_bios_data;
|
|---|
| 705 | /**ptr1 = 0x68;
|
|---|
| 706 | *(uint16*)(ptr1+1) = pm_info->sel_code;
|
|---|
| 707 | *(uint32*)(ptr1+3) = 0x0798bf07;
|
|---|
| 708 | *(uint32*)ptr2 = 0x0798be66;
|
|---|
| 709 | *(uint16*)(ptr2+4) = 0x0000;*/
|
|---|
| 710 | /*memcpy( bios_data+0x449, video_table1, sizeof(video_table1) );
|
|---|
| 711 | memcpy( bios_data+0x484, video_table2, sizeof(video_table2) );
|
|---|
| 712 | *(uint16*)(bios_data+0x4a8) = 0x2878;
|
|---|
| 713 | *(uint16*)(bios_data+0x4a8+2) = pm_info->sel_code;*/
|
|---|
| 714 | #endif
|
|---|
| 715 | dprintf( "vesa3: nVidia: patching done.\n" );
|
|---|
| 716 | }
|
|---|
| 717 | else {
|
|---|
| 718 | farcall.offset = 0;
|
|---|
| 719 | farcall.seg = i386_selector_add( SELECTOR(vesa3_call_retf,0x20-1,CODE_r,false) );
|
|---|
| 720 | retn |= sel_code<<16;
|
|---|
| 721 | }
|
|---|
| 722 |
|
|---|
| 723 | ret_val = id = vm_map_physical_memory( sp, "video_mem", (void**)&video_mem,
|
|---|
| 724 | REGION_ADDR_ANY_ADDRESS, 0x20000, LOCK_RW | LOCK_KERNEL, (addr_t)0xa0000 );
|
|---|
| 725 | if ( ret_val < 0 )
|
|---|
| 726 | goto no_vesa3;
|
|---|
| 727 |
|
|---|
| 728 | pm_info->sel_a0000 = i386_selector_add( SELECTOR(video_mem,0x10000-1,DATA_w,false) );
|
|---|
| 729 | pm_info->sel_b0000 = i386_selector_add( SELECTOR(video_mem+0x10000,0x10000-1,DATA_w,false) );
|
|---|
| 730 | pm_info->sel_b8000 = i386_selector_add( SELECTOR(video_mem+0x18000,0x8000-1,DATA_w,false) );
|
|---|
| 731 | /*
|
|---|
| 732 | pm_info->sel_a0000 = i386_selector_add( SELECTOR(0xa0000,0x10000-1,DATA_w,false) );
|
|---|
| 733 | pm_info->sel_b0000 = i386_selector_add( SELECTOR(0xb0000,0x8000-1,DATA_w,false) );
|
|---|
| 734 | pm_info->sel_b8000 = i386_selector_add( SELECTOR(0xb8000,0x8000-1,DATA_w,false) );*/
|
|---|
| 735 |
|
|---|
| 736 | pm_info->in_pm = 1;
|
|---|
| 737 |
|
|---|
| 738 | /* // print some debug info
|
|---|
| 739 | dprintf( "vesa3: video_bios: 0x%x\n", (int)video_bios );
|
|---|
| 740 | dprintf( "vesa3: init_offs: 0x%x\n", (int)video_bios+(int)pm_info->init_offs );
|
|---|
| 741 | dprintf( "vesa3: call_offs: 0x%x\n", (int)video_bios+(int)pm_info->call_offs );
|
|---|
| 742 | dprintf( "vesa3: vesa_call: 0x%x\n", (int)vesa_call );
|
|---|
| 743 | dprintf( "vesa3: vesa3_call_retf: 0x%x\n", (int)vesa3_call_retf );*/
|
|---|
| 744 |
|
|---|
| 745 | /*#ifdef DIAMOND_VIPER_V550_1_93E
|
|---|
| 746 | // patch
|
|---|
| 747 | ptr = (char *)((int)video_bios+0x4885);
|
|---|
| 748 | *ptr++ = 0xeb; // jmp
|
|---|
| 749 | *ptr++ = 0x17; // +0x17
|
|---|
| 750 | ptr = (char *)((int)video_bios+0x2f9d);
|
|---|
| 751 | *ptr++ = 0x1e; // push ds
|
|---|
| 752 | *ptr++ = 0x07; // pop es
|
|---|
| 753 | *ptr++ = 0xbf; // mov di,0x600
|
|---|
| 754 | *ptr++ = 0x00;
|
|---|
| 755 | *ptr++ = 0x06;
|
|---|
| 756 | *ptr++ = 0x90; // nop
|
|---|
| 757 | *ptr++ = 0x90; // nop
|
|---|
| 758 | ptr = (char *)((int)video_bios+0x3388);
|
|---|
| 759 | *ptr++ = 0x1f; // pop ds
|
|---|
| 760 | *ptr++ = 0xeb; // jmp
|
|---|
| 761 | *ptr++ = 0x15; // +0x15
|
|---|
| 762 | ptr = (char *)((int)video_bios+0x3085);
|
|---|
| 763 | *ptr++ = 0xeb; // jmp
|
|---|
| 764 | *ptr++ = 0x41; // +0x41
|
|---|
| 765 | ptr = video_bios+0x69ac;
|
|---|
| 766 | *(uint32*)ptr = 0x0600be66; // mov esi,0x600
|
|---|
| 767 | *(uint16*)(ptr+4) = 0x0000;
|
|---|
| 768 |
|
|---|
| 769 | ptr = video_bios+0xf000;
|
|---|
| 770 | *ptr++ = 0x66; // mov esi,retn
|
|---|
| 771 | *ptr++ = 0xbe;
|
|---|
| 772 | *((int32*)ptr)++ = &retn;
|
|---|
| 773 | *ptr++ = 0x67; // mov si,[esi]
|
|---|
| 774 | *ptr++ = 0x8b;
|
|---|
| 775 | *ptr++ = 0x36;
|
|---|
| 776 | *ptr++ = 0x68; // push 0
|
|---|
| 777 | *ptr++ = 0x00;
|
|---|
| 778 | *ptr++ = 0x00;
|
|---|
| 779 | *ptr++ = 0xff; // call si
|
|---|
| 780 | *ptr++ = 0xd6;
|
|---|
| 781 | *ptr++ = 0x66; // o32
|
|---|
| 782 | *ptr++ = 0xcb; // retf
|
|---|
| 783 | #else
|
|---|
| 784 | #endif*/
|
|---|
| 785 |
|
|---|
| 786 | dprintf( "vesa3: calling init...\n" );
|
|---|
| 787 |
|
|---|
| 788 | regs.es = 0;
|
|---|
| 789 | vesa_call( ®s ); // init
|
|---|
| 790 | retn = (retn & 0xffff0000) | pm_info->call_offs;
|
|---|
| 791 |
|
|---|
| 792 | dprintf( "vesa3: reading controller information...\n" );
|
|---|
| 793 |
|
|---|
| 794 | regs.ax = 0x4f00;
|
|---|
| 795 | regs.es = sel_infoblock = i386_selector_add( SELECTOR(&infoblock,sizeof(infoblock)-1,DATA_w,false) );
|
|---|
| 796 | regs.di = 0;
|
|---|
| 797 | infoblock.signature = 'V'|('B'<<8)|('E'<<16)|('2'<<24);
|
|---|
| 798 | vesa_call( ®s ); // get VBE controller information
|
|---|
| 799 | i386_selector_remove( sel_infoblock );
|
|---|
| 800 |
|
|---|
| 801 | dprintf( "vesa3: signature: %4s, version: 0x%x\n", (char*)&infoblock.signature, infoblock.version );
|
|---|
| 802 |
|
|---|
| 803 | resolve_farptr( &infoblock.oem_string_ptr );
|
|---|
| 804 | if ( infoblock.oem_string_ptr )
|
|---|
| 805 | dprintf( "vesa3: OEM string: %s\n", (char*)infoblock.oem_string_ptr );
|
|---|
| 806 |
|
|---|
| 807 | resolve_farptr( &infoblock.oem_vendor_name_ptr );
|
|---|
| 808 | if ( infoblock.oem_vendor_name_ptr )
|
|---|
| 809 | dprintf( "vesa3: OEM vendor name: %s\n", (char*)infoblock.oem_vendor_name_ptr );
|
|---|
| 810 |
|
|---|
| 811 | resolve_farptr( &infoblock.oem_product_name_ptr );
|
|---|
| 812 | if ( infoblock.oem_product_name_ptr )
|
|---|
| 813 | dprintf( "vesa3: OEM product name: %s\n", (char*)infoblock.oem_product_name_ptr );
|
|---|
| 814 |
|
|---|
| 815 | resolve_farptr( &infoblock.video_mode_ptr );
|
|---|
| 816 | #if 0 // broken ATI bios
|
|---|
| 817 | {
|
|---|
| 818 | struct s_farcall farcall_bak = farcall;
|
|---|
| 819 | int retn_bak = retn;
|
|---|
| 820 |
|
|---|
| 821 | farcall.offset = 0xf000;
|
|---|
| 822 | farcall.seg = sel_code;
|
|---|
| 823 | retn = 0x9ba0;
|
|---|
| 824 |
|
|---|
| 825 | video_bios[0x9bd7] = 0x00; //0x21;
|
|---|
| 826 |
|
|---|
| 827 | ptr = video_bios+0xf000;
|
|---|
| 828 | dprintf( "vesa3: creating stub code at %x...\n", (int)ptr );
|
|---|
| 829 | *((uint16*)ptr)++ = 0xbe66; // mov esi,retn
|
|---|
| 830 | *((int32*)ptr)++ = (int32)&retn;
|
|---|
| 831 | *((uint32*)ptr)++ = 0xff368b67; // mov si,[esi]
|
|---|
| 832 | *((uint32*)ptr)++ = 0xcb66d6; // call si; o32 retf
|
|---|
| 833 |
|
|---|
| 834 | for ( i = 0; ; i++ ) {
|
|---|
| 835 | regs.bx = i<<8;
|
|---|
| 836 | regs.es = pm_info->sel_code;
|
|---|
| 837 | regs.di = 0x9b8e; //0x1f32
|
|---|
| 838 | vesa_call( ®s ); // init
|
|---|
| 839 | }
|
|---|
| 840 |
|
|---|
| 841 | farcall = farcall_bak;
|
|---|
| 842 | retn = retn_bak;
|
|---|
| 843 | }
|
|---|
| 844 | #endif
|
|---|
| 845 |
|
|---|
| 846 | dprintf( "vesa3: successfully initialized!\n" );
|
|---|
| 847 |
|
|---|
| 848 | ret_val = devfs_publish_indexed_device( "graphics/vesa3/fb", NULL, &vesa3_hooks );
|
|---|
| 849 | if ( ret_val >= 0 )
|
|---|
| 850 | return NO_ERROR;
|
|---|
| 851 | //ret_val = devfs_publish_indexed_device( "graphics/fb", NULL, &vesa3_hooks );
|
|---|
| 852 |
|
|---|
| 853 | vm_delete_region( sp, id );
|
|---|
| 854 | no_vesa3:
|
|---|
| 855 | kfree( bios_stack );
|
|---|
| 856 | no_vesa2:
|
|---|
| 857 | kfree( bios_data );
|
|---|
| 858 | no_vesa1:
|
|---|
| 859 | kfree( video_bios );
|
|---|
| 860 | dprintf( "vesa3: failed.\n" );
|
|---|
| 861 |
|
|---|
| 862 | return ret_val;
|
|---|
| 863 | }
|
|---|
