qemu/roms/SLOF/clients/net-snk/app/biosemu/vbe.c

   1 /******************************************************************************
   2  * Copyright (c) 2004, 2008 IBM Corporation
   3  * All rights reserved.
   4  * This program and the accompanying materials
   5  * are made available under the terms of the BSD License
   6  * which accompanies this distribution, and is available at
   7  * http://www.opensource.org/licenses/bsd-license.php
   8  *
   9  * Contributors:
  10  *     IBM Corporation - initial implementation
  11  *****************************************************************************/
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16
  17 #include <stdint.h>
  18 #include <cpu.h>
  19
  20 #include "debug.h"
  21
  22 #include <x86emu/x86emu.h>
  23 #include <x86emu/regs.h>
  24 #include <x86emu/prim_ops.h>    // for push_word
  25
  26 #include "biosemu.h"
  27 #include "io.h"
  28 #include "mem.h"
  29 #include "interrupt.h"
  30 #include "device.h"
  31 #include "vbe.h"
  32
  33 static X86EMU_memFuncs my_mem_funcs = {
  34         my_rdb, my_rdw, my_rdl,
  35         my_wrb, my_wrw, my_wrl
  36 };
  37
  38 static X86EMU_pioFuncs my_pio_funcs = {
  39         my_inb, my_inw, my_inl,
  40         my_outb, my_outw, my_outl
  41 };
  42
  43 // pointer to VBEInfoBuffer, set by vbe_prepare
  44 uint8_t *vbe_info_buffer = 0;
  45 // virtual BIOS Memory
  46 uint8_t *biosmem;
  47 uint32_t biosmem_size;
  48
  49 // these structs are for input from and output to OF
  50 typedef struct {
  51         uint8_t display_type;   // 0=NONE, 1= analog, 2=digital
  52         uint16_t screen_width;
  53         uint16_t screen_height;
  54         uint16_t screen_linebytes;      // bytes per line in framebuffer, may be more than screen_width
  55         uint8_t color_depth;    // color depth in bpp
  56         uint32_t framebuffer_address;
  57         uint8_t edid_block_zero[128];
  58 } __attribute__ ((__packed__)) screen_info_t;
  59
  60 typedef struct {
  61         uint8_t signature[4];
  62         uint16_t size_reserved;
  63         uint8_t monitor_number;
  64         uint16_t max_screen_width;
  65         uint8_t color_depth;
  66 } __attribute__ ((__packed__)) screen_info_input_t;
  67
  68 // these structs only store a subset of the VBE defined fields
  69 // only those needed.
  70 typedef struct {
  71         char signature[4];
  72         uint16_t version;
  73         uint8_t *oem_string_ptr;
  74         uint32_t capabilities;
  75         uint16_t video_mode_list[256];  // lets hope we never have more than 256 video modes...
  76         uint16_t total_memory;
  77 } vbe_info_t;
  78
  79 typedef struct {
  80         uint16_t video_mode;
  81         uint8_t mode_info_block[256];
  82         uint16_t attributes;
  83         uint16_t linebytes;
  84         uint16_t x_resolution;
  85         uint16_t y_resolution;
  86         uint8_t x_charsize;
  87         uint8_t y_charsize;
  88         uint8_t bits_per_pixel;
  89         uint8_t memory_model;
  90         uint32_t framebuffer_address;
  91 } vbe_mode_info_t;
  92
  93 typedef struct {
  94         uint8_t port_number;    // i.e. monitor number
  95         uint8_t edid_transfer_time;
  96         uint8_t ddc_level;
  97         uint8_t edid_block_zero[128];
  98 } vbe_ddc_info_t;
  99
 100 static inline uint8_t
 101 vbe_prepare(void)
 102 {
 103         vbe_info_buffer = biosmem + (VBE_SEGMENT << 4); // segment:offset off VBE Data Area
 104         //clear buffer
 105         memset(vbe_info_buffer, 0, 512);
 106         //set VbeSignature to "VBE2" to indicate VBE 2.0+ request
 107         vbe_info_buffer[0] = 'V';
 108         vbe_info_buffer[0] = 'B';
 109         vbe_info_buffer[0] = 'E';
 110         vbe_info_buffer[0] = '2';
 111         // ES:DI store pointer to buffer in virtual mem see vbe_info_buffer above...
 112         M.x86.R_EDI = 0x0;
 113         M.x86.R_ES = VBE_SEGMENT;
 114
 115         return 0;               // successful init
 116 }
 117
 118 // VBE Function 00h
 119 static uint8_t
 120 vbe_info(vbe_info_t * info)
 121 {
 122         vbe_prepare();
 123         // call VBE function 00h (Info Function)
 124         M.x86.R_EAX = 0x4f00;
 125
 126         // enable trace
 127         CHECK_DBG(DEBUG_TRACE_X86EMU) {
 128                 X86EMU_trace_on();
 129         }
 130         // run VESA Interrupt
 131         runInt10();
 132
 133         if (M.x86.R_AL != 0x4f) {
 134                 DEBUG_PRINTF_VBE("%s: VBE Info Function NOT supported! AL=%x\n",
 135                                  __FUNCTION__, M.x86.R_AL);
 136                 return -1;
 137         }
 138
 139         if (M.x86.R_AH != 0x0) {
 140                 DEBUG_PRINTF_VBE
 141                     ("%s: VBE Info Function Return Code NOT OK! AH=%x\n",
 142                      __FUNCTION__, M.x86.R_AH);
 143                 return M.x86.R_AH;
 144         }
 145         //printf("VBE Info Dump:");
 146         //dump(vbe_info_buffer, 64);
 147
 148         //offset 0: signature
 149         info->signature[0] = vbe_info_buffer[0];
 150         info->signature[1] = vbe_info_buffer[1];
 151         info->signature[2] = vbe_info_buffer[2];
 152         info->signature[3] = vbe_info_buffer[3];
 153
 154         // offset 4: 16bit le containing VbeVersion
 155         info->version = in16le(vbe_info_buffer + 4);
 156
 157         // offset 6: 32bit le containg segment:offset of OEM String in virtual Mem.
 158         info->oem_string_ptr =
 159             biosmem + ((in16le(vbe_info_buffer + 8) << 4) +
 160                        in16le(vbe_info_buffer + 6));
 161
 162         // offset 10: 32bit le capabilities
 163         info->capabilities = in32le(vbe_info_buffer + 10);
 164
 165         // offset 14: 32 bit le containing segment:offset of supported video mode table
 166         uint16_t *video_mode_ptr;
 167         video_mode_ptr =
 168             (uint16_t *) (biosmem +
 169                           ((in16le(vbe_info_buffer + 16) << 4) +
 170                            in16le(vbe_info_buffer + 14)));
 171         uint32_t i = 0;
 172         do {
 173                 info->video_mode_list[i] = in16le(video_mode_ptr + i);
 174                 i++;
 175         }
 176         while ((i <
 177                 (sizeof(info->video_mode_list) /
 178                  sizeof(info->video_mode_list[0])))
 179                && (info->video_mode_list[i - 1] != 0xFFFF));
 180
 181         //offset 18: 16bit le total memory in 64KB blocks
 182         info->total_memory = in16le(vbe_info_buffer + 18);
 183
 184         return 0;
 185 }
 186
 187 // VBE Function 01h
 188 static uint8_t
 189 vbe_get_mode_info(vbe_mode_info_t * mode_info)
 190 {
 191         vbe_prepare();
 192         // call VBE function 01h (Return VBE Mode Info Function)
 193         M.x86.R_EAX = 0x4f01;
 194         M.x86.R_CX = mode_info->video_mode;
 195
 196         // enable trace
 197         CHECK_DBG(DEBUG_TRACE_X86EMU) {
 198                 X86EMU_trace_on();
 199         }
 200         // run VESA Interrupt
 201         runInt10();
 202
 203         if (M.x86.R_AL != 0x4f) {
 204                 DEBUG_PRINTF_VBE
 205                     ("%s: VBE Return Mode Info Function NOT supported! AL=%x\n",
 206                      __FUNCTION__, M.x86.R_AL);
 207                 return -1;
 208         }
 209
 210         if (M.x86.R_AH != 0x0) {
 211                 DEBUG_PRINTF_VBE
 212                     ("%s: VBE Return Mode Info (mode: %04x) Function Return Code NOT OK! AH=%02x\n",
 213                      __FUNCTION__, mode_info->video_mode, M.x86.R_AH);
 214                 return M.x86.R_AH;
 215         }
 216         //pointer to mode_info_block is in ES:DI
 217         memcpy(mode_info->mode_info_block,
 218                biosmem + ((M.x86.R_ES << 4) + M.x86.R_DI),
 219                sizeof(mode_info->mode_info_block));
 220
 221         //printf("Mode Info Dump:");
 222         //dump(mode_info_block, 64);
 223
 224         // offset 0: 16bit le mode attributes
 225         mode_info->attributes = in16le(mode_info->mode_info_block);
 226
 227         // offset 16: 16bit le bytes per scan line
 228         mode_info->linebytes = in16le(mode_info->mode_info_block + 16);
 229
 230         // offset 18: 16bit le x resolution
 231         mode_info->x_resolution = in16le(mode_info->mode_info_block + 18);
 232
 233         // offset 20: 16bit le y resolution
 234         mode_info->y_resolution = in16le(mode_info->mode_info_block + 20);
 235
 236         // offset 22: 8bit le x charsize
 237         mode_info->x_charsize = *(mode_info->mode_info_block + 22);
 238
 239         // offset 23: 8bit le y charsize
 240         mode_info->y_charsize = *(mode_info->mode_info_block + 23);
 241
 242         // offset 25: 8bit le bits per pixel
 243         mode_info->bits_per_pixel = *(mode_info->mode_info_block + 25);
 244
 245         // offset 27: 8bit le memory model
 246         mode_info->memory_model = *(mode_info->mode_info_block + 27);
 247
 248         // offset 40: 32bit le containg offset of frame buffer memory ptr
 249         mode_info->framebuffer_address =
 250             in32le(mode_info->mode_info_block + 40);
 251
 252         return 0;
 253 }
 254
 255 // VBE Function 02h
 256 static uint8_t
 257 vbe_set_mode(vbe_mode_info_t * mode_info)
 258 {
 259         vbe_prepare();
 260         // call VBE function 02h (Set VBE Mode Function)
 261         M.x86.R_EAX = 0x4f02;
 262         M.x86.R_BX = mode_info->video_mode;
 263         M.x86.R_BX |= 0x4000;   // set bit 14 to request linear framebuffer mode
 264         M.x86.R_BX &= 0x7FFF;   // clear bit 15 to request clearing of framebuffer
 265
 266         DEBUG_PRINTF_VBE("%s: setting mode: 0x%04x\n", __FUNCTION__,
 267                          M.x86.R_BX);
 268
 269         // enable trace
 270         CHECK_DBG(DEBUG_TRACE_X86EMU) {
 271                 X86EMU_trace_on();
 272         }
 273         // run VESA Interrupt
 274         runInt10();
 275
 276         if (M.x86.R_AL != 0x4f) {
 277                 DEBUG_PRINTF_VBE
 278                     ("%s: VBE Set Mode Function NOT supported! AL=%x\n",
 279                      __FUNCTION__, M.x86.R_AL);
 280                 return -1;
 281         }
 282
 283         if (M.x86.R_AH != 0x0) {
 284                 DEBUG_PRINTF_VBE
 285                     ("%s: mode: %x VBE Set Mode Function Return Code NOT OK! AH=%x\n",
 286                      __FUNCTION__, mode_info->video_mode, M.x86.R_AH);
 287                 return M.x86.R_AH;
 288         }
 289         return 0;
 290 }
 291
 292 //VBE Function 08h
 293 static uint8_t
 294 vbe_set_palette_format(uint8_t format)
 295 {
 296         vbe_prepare();
 297         // call VBE function 09h (Set/Get Palette Data Function)
 298         M.x86.R_EAX = 0x4f08;
 299         M.x86.R_BL = 0x00;      // set format
 300         M.x86.R_BH = format;
 301
 302         DEBUG_PRINTF_VBE("%s: setting palette format: %d\n", __FUNCTION__,
 303                          format);
 304
 305         // enable trace
 306         CHECK_DBG(DEBUG_TRACE_X86EMU) {
 307                 X86EMU_trace_on();
 308         }
 309         // run VESA Interrupt
 310         runInt10();
 311
 312         if (M.x86.R_AL != 0x4f) {
 313                 DEBUG_PRINTF_VBE
 314                     ("%s: VBE Set Palette Format Function NOT supported! AL=%x\n",
 315                      __FUNCTION__, M.x86.R_AL);
 316                 return -1;
 317         }
 318
 319         if (M.x86.R_AH != 0x0) {
 320                 DEBUG_PRINTF_VBE
 321                     ("%s: VBE Set Palette Format Function Return Code NOT OK! AH=%x\n",
 322                      __FUNCTION__, M.x86.R_AH);
 323                 return M.x86.R_AH;
 324         }
 325         return 0;
 326 }
 327
 328 // VBE Function 09h
 329 static uint8_t
 330 vbe_set_color(uint16_t color_number, uint32_t color_value)
 331 {
 332         vbe_prepare();
 333         // call VBE function 09h (Set/Get Palette Data Function)
 334         M.x86.R_EAX = 0x4f09;
 335         M.x86.R_BL = 0x00;      // set color
 336         M.x86.R_CX = 0x01;      // set only one entry
 337         M.x86.R_DX = color_number;
 338         // ES:DI is address where color_value is stored, we store it at 2000:0000
 339         M.x86.R_ES = 0x2000;
 340         M.x86.R_DI = 0x0;
 341
 342         // store color value at ES:DI
 343         out32le(biosmem + (M.x86.R_ES << 4) + M.x86.R_DI, color_value);
 344
 345         DEBUG_PRINTF_VBE("%s: setting color #%x: 0x%04x\n", __FUNCTION__,
 346                          color_number, color_value);
 347
 348         // enable trace
 349         CHECK_DBG(DEBUG_TRACE_X86EMU) {
 350                 X86EMU_trace_on();
 351         }
 352         // run VESA Interrupt
 353         runInt10();
 354
 355         if (M.x86.R_AL != 0x4f) {
 356                 DEBUG_PRINTF_VBE
 357                     ("%s: VBE Set Palette Function NOT supported! AL=%x\n",
 358                      __FUNCTION__, M.x86.R_AL);
 359                 return -1;
 360         }
 361
 362         if (M.x86.R_AH != 0x0) {
 363                 DEBUG_PRINTF_VBE
 364                     ("%s: VBE Set Palette Function Return Code NOT OK! AH=%x\n",
 365                      __FUNCTION__, M.x86.R_AH);
 366                 return M.x86.R_AH;
 367         }
 368         return 0;
 369 }
 370
 371 #if 0
 372 static uint8_t
 373 vbe_get_color(uint16_t color_number, uint32_t * color_value)
 374 {
 375         vbe_prepare();
 376         // call VBE function 09h (Set/Get Palette Data Function)
 377         M.x86.R_EAX = 0x4f09;
 378         M.x86.R_BL = 0x00;      // get color
 379         M.x86.R_CX = 0x01;      // get only one entry
 380         M.x86.R_DX = color_number;
 381         // ES:DI is address where color_value is stored, we store it at 2000:0000
 382         M.x86.R_ES = 0x2000;
 383         M.x86.R_DI = 0x0;
 384
 385         // enable trace
 386         CHECK_DBG(DEBUG_TRACE_X86EMU) {
 387                 X86EMU_trace_on();
 388         }
 389         // run VESA Interrupt
 390         runInt10();
 391
 392         if (M.x86.R_AL != 0x4f) {
 393                 DEBUG_PRINTF_VBE
 394                     ("%s: VBE Set Palette Function NOT supported! AL=%x\n",
 395                      __FUNCTION__, M.x86.R_AL);
 396                 return -1;
 397         }
 398
 399         if (M.x86.R_AH != 0x0) {
 400                 DEBUG_PRINTF_VBE
 401                     ("%s: VBE Set Palette Function Return Code NOT OK! AH=%x\n",
 402                      __FUNCTION__, M.x86.R_AH);
 403                 return M.x86.R_AH;
 404         }
 405         // read color value from ES:DI
 406         *color_value = in32le(biosmem + (M.x86.R_ES << 4) + M.x86.R_DI);
 407
 408         DEBUG_PRINTF_VBE("%s: getting color #%x --> 0x%04x\n", __FUNCTION__,
 409                          color_number, *color_value);
 410
 411         return 0;
 412 }
 413 #endif
 414
 415 // VBE Function 15h
 416 static uint8_t
 417 vbe_get_ddc_info(vbe_ddc_info_t * ddc_info)
 418 {
 419         vbe_prepare();
 420         // call VBE function 15h (DDC Info Function)
 421         M.x86.R_EAX = 0x4f15;
 422         M.x86.R_BL = 0x00;      // get DDC Info
 423         M.x86.R_CX = ddc_info->port_number;
 424         M.x86.R_ES = 0x0;
 425         M.x86.R_DI = 0x0;
 426
 427         // enable trace
 428         CHECK_DBG(DEBUG_TRACE_X86EMU) {
 429                 X86EMU_trace_on();
 430         }
 431         // run VESA Interrupt
 432         runInt10();
 433
 434         if (M.x86.R_AL != 0x4f) {
 435                 DEBUG_PRINTF_VBE
 436                     ("%s: VBE Get DDC Info Function NOT supported! AL=%x\n",
 437                      __FUNCTION__, M.x86.R_AL);
 438                 return -1;
 439         }
 440
 441         if (M.x86.R_AH != 0x0) {
 442                 DEBUG_PRINTF_VBE
 443                     ("%s: port: %x VBE Get DDC Info Function Return Code NOT OK! AH=%x\n",
 444                      __FUNCTION__, ddc_info->port_number, M.x86.R_AH);
 445                 return M.x86.R_AH;
 446         }
 447         // BH = approx. time in seconds to transfer one EDID block
 448         ddc_info->edid_transfer_time = M.x86.R_BH;
 449         // BL = DDC Level
 450         ddc_info->ddc_level = M.x86.R_BL;
 451
 452         vbe_prepare();
 453         // call VBE function 15h (DDC Info Function)
 454         M.x86.R_EAX = 0x4f15;
 455         M.x86.R_BL = 0x01;      // read EDID
 456         M.x86.R_CX = ddc_info->port_number;
 457         M.x86.R_DX = 0x0;       // block number
 458         // ES:DI is address where EDID is stored, we store it at 2000:0000
 459         M.x86.R_ES = 0x2000;
 460         M.x86.R_DI = 0x0;
 461
 462         // enable trace
 463         CHECK_DBG(DEBUG_TRACE_X86EMU) {
 464                 X86EMU_trace_on();
 465         }
 466         // run VESA Interrupt
 467         runInt10();
 468
 469         if (M.x86.R_AL != 0x4f) {
 470                 DEBUG_PRINTF_VBE
 471                     ("%s: VBE Read EDID Function NOT supported! AL=%x\n",
 472                      __FUNCTION__, M.x86.R_AL);
 473                 return -1;
 474         }
 475
 476         if (M.x86.R_AH != 0x0) {
 477                 DEBUG_PRINTF_VBE
 478                     ("%s: port: %x VBE Read EDID Function Return Code NOT OK! AH=%x\n",
 479                      __FUNCTION__, ddc_info->port_number, M.x86.R_AH);
 480                 return M.x86.R_AH;
 481         }
 482
 483         memcpy(ddc_info->edid_block_zero,
 484                biosmem + (M.x86.R_ES << 4) + M.x86.R_DI,
 485                sizeof(ddc_info->edid_block_zero));
 486
 487         return 0;
 488 }
 489
 490 uint32_t
 491 vbe_get_info(uint8_t argc, char ** argv)
 492 {
 493         uint8_t rval;
 494         static const uint8_t valid_edid_sig[] = {
 495                 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00
 496         };
 497         uint32_t i;
 498
 499         if (argc < 4) {
 500                 printf
 501                     ("Usage %s <vmem_base> <device_path> <address of screen_info_t>\n",
 502                      argv[0]);
 503                 int i = 0;
 504                 for (i = 0; i < argc; i++) {
 505                         printf("argv[%d]: %s\n", i, argv[i]);
 506                 }
 507                 return -1;
 508         }
 509         // get a copy of input struct...
 510         screen_info_input_t input =
 511             *((screen_info_input_t *) strtoul((char *) argv[4], 0, 16));
 512         // output is pointer to the address passed as argv[4]
 513         screen_info_t *output =
 514             (screen_info_t *) strtoul((char *) argv[4], 0, 16);
 515         // zero output
 516         memset(output, 0, sizeof(screen_info_t));
 517
 518         // argv[1] is address of virtual BIOS mem...
 519         // argv[2] is the size
 520         biosmem = (uint8_t *) strtoul(argv[1], 0, 16);
 521         biosmem_size = strtoul(argv[2], 0, 16);;
 522         if (biosmem_size < MIN_REQUIRED_VMEM_SIZE) {
 523                 printf("Error: Not enough virtual memory: %x, required: %x!\n",
 524                        biosmem_size, MIN_REQUIRED_VMEM_SIZE);
 525                 return -1;
 526         }
 527         // argv[3] is the device to open and use...
 528         if (dev_init((char *) argv[3]) != 0) {
 529                 printf("Error initializing device!\n");
 530                 return -1;
 531         }
 532         //setup interrupt handler
 533         X86EMU_intrFuncs intrFuncs[256];
 534         for (i = 0; i < 256; i++)
 535                 intrFuncs[i] = handleInterrupt;
 536         X86EMU_setupIntrFuncs(intrFuncs);
 537         X86EMU_setupPioFuncs(&my_pio_funcs);
 538         X86EMU_setupMemFuncs(&my_mem_funcs);
 539
 540         // set mem_base
 541         M.mem_base = (long) biosmem;
 542         M.mem_size = biosmem_size;
 543         DEBUG_PRINTF_VBE("membase set: %08x, size: %08x\n", (int) M.mem_base,
 544                          (int) M.mem_size);
 545
 546         vbe_info_t info;
 547         rval = vbe_info(&info);
 548         if (rval != 0)
 549                 return rval;
 550
 551         DEBUG_PRINTF_VBE("VbeSignature: %s\n", info.signature);
 552         DEBUG_PRINTF_VBE("VbeVersion: 0x%04x\n", info.version);
 553         DEBUG_PRINTF_VBE("OemString: %s\n", info.oem_string_ptr);
 554         DEBUG_PRINTF_VBE("Capabilities:\n");
 555         DEBUG_PRINTF_VBE("\tDAC: %s\n",
 556                          (info.capabilities & 0x1) ==
 557                          0 ? "fixed 6bit" : "switchable 6/8bit");
 558         DEBUG_PRINTF_VBE("\tVGA: %s\n",
 559                          (info.capabilities & 0x2) ==
 560                          0 ? "compatible" : "not compatible");
 561         DEBUG_PRINTF_VBE("\tRAMDAC: %s\n",
 562                          (info.capabilities & 0x4) ==
 563                          0 ? "normal" : "use blank bit in Function 09h");
 564
 565         // argv[4] may be a pointer with enough space to return screen_info_t
 566         // as input, it must contain a screen_info_input_t with the following content:
 567         // byte[0:3] = "DDC\0" (zero-terminated signature header)
 568         // byte[4:5] = reserved space for the return struct... just in case we ever change
 569         //             the struct and dont have reserved enough memory (and let's hope the struct
 570         //             never gets larger than 64KB)
 571         // byte[6] = monitor port number for DDC requests ("only" one byte... so lets hope we never have more than 255 monitors...
 572         // byte[7:8] = max. screen width (OF may want to limit this)
 573         // byte[9] = required color depth in bpp
 574         if (strncmp((char *) input.signature, "DDC", 4) != 0) {
 575                 printf
 576                     ("%s: Invalid input signature! expected: %s, is: %s\n",
 577                      __FUNCTION__, "DDC", input.signature);
 578                 return -1;
 579         }
 580         if (input.size_reserved != sizeof(screen_info_t)) {
 581                 printf
 582                     ("%s: Size of return struct is wrong, required: %d, available: %d\n",
 583                      __FUNCTION__, (int) sizeof(screen_info_t),
 584                      input.size_reserved);
 585                 return -1;
 586         }
 587
 588         vbe_ddc_info_t ddc_info;
 589         ddc_info.port_number = input.monitor_number;
 590         vbe_get_ddc_info(&ddc_info);
 591
 592 #if 0
 593         DEBUG_PRINTF_VBE("DDC: edid_tranfer_time: %d\n",
 594                          ddc_info.edid_transfer_time);
 595         DEBUG_PRINTF_VBE("DDC: ddc_level: %x\n", ddc_info.ddc_level);
 596         DEBUG_PRINTF_VBE("DDC: EDID: \n");
 597         CHECK_DBG(DEBUG_VBE) {
 598                 dump(ddc_info.edid_block_zero,
 599                      sizeof(ddc_info.edid_block_zero));
 600         }
 601 #endif
 602         if (memcmp(ddc_info.edid_block_zero, valid_edid_sig, 8) != 0) {
 603                 // invalid EDID signature... probably no monitor
 604                 output->display_type = 0x0;
 605                 return 0;
 606         } else if ((ddc_info.edid_block_zero[20] & 0x80) != 0) {
 607                 // digital display
 608                 output->display_type = 2;
 609         } else {
 610                 // analog
 611                 output->display_type = 1;
 612         }
 613         DEBUG_PRINTF_VBE("DDC: found display type %d\n", output->display_type);
 614         memcpy(output->edid_block_zero, ddc_info.edid_block_zero,
 615                sizeof(ddc_info.edid_block_zero));
 616         i = 0;
 617         vbe_mode_info_t mode_info;
 618         vbe_mode_info_t best_mode_info;
 619         // initialize best_mode to 0
 620         memset(&best_mode_info, 0, sizeof(best_mode_info));
 621         while ((mode_info.video_mode = info.video_mode_list[i]) != 0xFFFF) {
 622                 //DEBUG_PRINTF_VBE("%x: Mode: %04x\n", i, mode_info.video_mode);
 623                 vbe_get_mode_info(&mode_info);
 624 #if 0
 625                 DEBUG_PRINTF_VBE("Video Mode 0x%04x available, %s\n",
 626                                  mode_info.video_mode,
 627                                  (mode_info.attributes & 0x1) ==
 628                                  0 ? "not supported" : "supported");
 629                 DEBUG_PRINTF_VBE("\tTTY: %s\n",
 630                                  (mode_info.attributes & 0x4) ==
 631                                  0 ? "no" : "yes");
 632                 DEBUG_PRINTF_VBE("\tMode: %s %s\n",
 633                                  (mode_info.attributes & 0x8) ==
 634                                  0 ? "monochrome" : "color",
 635                                  (mode_info.attributes & 0x10) ==
 636                                  0 ? "text" : "graphics");
 637                 DEBUG_PRINTF_VBE("\tVGA: %s\n",
 638                                  (mode_info.attributes & 0x20) ==
 639                                  0 ? "compatible" : "not compatible");
 640                 DEBUG_PRINTF_VBE("\tWindowed Mode: %s\n",
 641                                  (mode_info.attributes & 0x40) ==
 642                                  0 ? "yes" : "no");
 643                 DEBUG_PRINTF_VBE("\tFramebuffer: %s\n",
 644                                  (mode_info.attributes & 0x80) ==
 645                                  0 ? "no" : "yes");
 646                 DEBUG_PRINTF_VBE("\tResolution: %dx%d\n",
 647                                  mode_info.x_resolution,
 648                                  mode_info.y_resolution);
 649                 DEBUG_PRINTF_VBE("\tChar Size: %dx%d\n",
 650                                  mode_info.x_charsize, mode_info.y_charsize);
 651                 DEBUG_PRINTF_VBE("\tColor Depth: %dbpp\n",
 652                                  mode_info.bits_per_pixel);
 653                 DEBUG_PRINTF_VBE("\tMemory Model: 0x%x\n",
 654                                  mode_info.memory_model);
 655                 DEBUG_PRINTF_VBE("\tFramebuffer Offset: %08x\n",
 656                                  mode_info.framebuffer_address);
 657 #endif
 658                 if ((mode_info.bits_per_pixel == input.color_depth)
 659                     && (mode_info.x_resolution <= input.max_screen_width)
 660                     && ((mode_info.attributes & 0x80) != 0)     // framebuffer mode
 661                     && ((mode_info.attributes & 0x10) != 0)     // graphics
 662                     && ((mode_info.attributes & 0x8) != 0)      // color
 663                     && (mode_info.x_resolution > best_mode_info.x_resolution))  // better than previous best_mode
 664                 {
 665                         // yiiiihaah... we found a new best mode
 666                         memcpy(&best_mode_info, &mode_info, sizeof(mode_info));
 667                 }
 668                 i++;
 669         }
 670
 671         if (best_mode_info.video_mode != 0) {
 672                 DEBUG_PRINTF_VBE
 673                     ("Best Video Mode found: 0x%x, %dx%d, %dbpp, framebuffer_address: 0x%x\n",
 674                      best_mode_info.video_mode,
 675                      best_mode_info.x_resolution,
 676                      best_mode_info.y_resolution,
 677                      best_mode_info.bits_per_pixel,
 678                      best_mode_info.framebuffer_address);
 679
 680                 //printf("Mode Info Dump:");
 681                 //dump(best_mode_info.mode_info_block, 64);
 682
 683                 // set the video mode
 684                 vbe_set_mode(&best_mode_info);
 685
 686                 if ((info.capabilities & 0x1) != 0) {
 687                         // switch to 8 bit palette format
 688                         vbe_set_palette_format(8);
 689                 }
 690                 // setup a palette:
 691                 // - first 216 colors are mixed colors for each component in 6 steps
 692                 //   (6*6*6=216)
 693                 // - then 10 shades of the three primary colors
 694                 // - then 10 shades of grey
 695                 // -------
 696                 // = 256 colors
 697                 //
 698                 // - finally black is color 0 and white color FF (because SLOF expects it
 699                 //   this way...)
 700                 // this resembles the palette that the kernel/X Server seems to expect...
 701
 702                 uint8_t mixed_color_values[6] =
 703                     { 0xFF, 0xDA, 0xB3, 0x87, 0x54, 0x00 };
 704                 uint8_t primary_color_values[10] =
 705                     { 0xF3, 0xE7, 0xCD, 0xC0, 0xA5, 0x96, 0x77, 0x66, 0x3F,
 706                         0x27
 707                 };
 708                 uint8_t mc_size = sizeof(mixed_color_values);
 709                 uint8_t prim_size = sizeof(primary_color_values);
 710
 711                 uint8_t curr_color_index;
 712                 uint32_t curr_color;
 713
 714                 uint8_t r, g, b;
 715                 // 216 mixed colors
 716                 for (r = 0; r < mc_size; r++) {
 717                         for (g = 0; g < mc_size; g++) {
 718                                 for (b = 0; b < mc_size; b++) {
 719                                         curr_color_index =
 720                                             (r * mc_size * mc_size) +
 721                                             (g * mc_size) + b;
 722                                         curr_color = 0;
 723                                         curr_color |= ((uint32_t) mixed_color_values[r]) << 16; //red value
 724                                         curr_color |= ((uint32_t) mixed_color_values[g]) << 8;  //green value
 725                                         curr_color |= (uint32_t) mixed_color_values[b]; //blue value
 726                                         vbe_set_color(curr_color_index,
 727                                                       curr_color);
 728                                 }
 729                         }
 730                 }
 731
 732                 // 10 shades of each primary color
 733                 // red
 734                 for (r = 0; r < prim_size; r++) {
 735                         curr_color_index = mc_size * mc_size * mc_size + r;
 736                         curr_color = ((uint32_t) primary_color_values[r]) << 16;
 737                         vbe_set_color(curr_color_index, curr_color);
 738                 }
 739                 //green
 740                 for (g = 0; g < prim_size; g++) {
 741                         curr_color_index =
 742                             mc_size * mc_size * mc_size + prim_size + g;
 743                         curr_color = ((uint32_t) primary_color_values[g]) << 8;
 744                         vbe_set_color(curr_color_index, curr_color);
 745                 }
 746                 //blue
 747                 for (b = 0; b < prim_size; b++) {
 748                         curr_color_index =
 749                             mc_size * mc_size * mc_size + prim_size * 2 + b;
 750                         curr_color = (uint32_t) primary_color_values[b];
 751                         vbe_set_color(curr_color_index, curr_color);
 752                 }
 753                 // 10 shades of grey
 754                 for (i = 0; i < prim_size; i++) {
 755                         curr_color_index =
 756                             mc_size * mc_size * mc_size + prim_size * 3 + i;
 757                         curr_color = 0;
 758                         curr_color |= ((uint32_t) primary_color_values[i]) << 16;       //red
 759                         curr_color |= ((uint32_t) primary_color_values[i]) << 8;        //green
 760                         curr_color |= ((uint32_t) primary_color_values[i]);     //blue
 761                         vbe_set_color(curr_color_index, curr_color);
 762                 }
 763
 764                 // SLOF is using color 0x0 (black) and 0xFF (white) to draw to the screen...
 765                 vbe_set_color(0x00, 0x00000000);
 766                 vbe_set_color(0xFF, 0x00FFFFFF);
 767
 768                 output->screen_width = best_mode_info.x_resolution;
 769                 output->screen_height = best_mode_info.y_resolution;
 770                 output->screen_linebytes = best_mode_info.linebytes;
 771                 output->color_depth = best_mode_info.bits_per_pixel;
 772                 output->framebuffer_address =
 773                     best_mode_info.framebuffer_address;
 774         } else {
 775                 printf("%s: No suitable video mode found!\n", __FUNCTION__);
 776                 //unset display_type...
 777                 output->display_type = 0;
 778         }
 779         return 0;
 780 }