VirtualBox

Changeset 33501 in vbox


Ignore:
Timestamp:
Oct 27, 2010 1:03:55 PM (14 years ago)
Author:
vboxsync
Message:

DevVGA: Folded conditional compilation which only made the code harder to maintain.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r33455 r33501  
    1 #ifdef VBOX
    21/* $Id$ */
    32/** @file
    … …  
    4544*   Defined Constants And Macros                                               *
    4645*******************************************************************************/
    47 #ifndef VBOX
    48 /** The default amount of VRAM. */
    49 #define VGA_VRAM_DEFAULT    (_4M)
    50 /** The maximum amount of VRAM. */
    51 #define VGA_VRAM_MAX        (128 * _1M)
    52 /** The minimum amount of VRAM. */
    53 #define VGA_VRAM_MIN        (_1M)
    54 #else
    55 /* moved to DevVGA.h */
    56 #endif
    5746
    5847/** The size of the VGA GC mapping.
    … …  
    387376}
    388377
    389 #endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
    390 #endif /* VBOX */
    391 #ifndef VBOX_DEVICE_STRUCT_TESTCASE
    392 
    393 #ifndef VBOX
    394 #include "vl.h"
    395 #include "vga_int.h"
    396 #endif /* !VBOX */
    397 
    398378#ifdef LOG_ENABLED
    399379//#define DEBUG_VGA
    … …  
    406386
    407387/* force some bits to zero */
    408 #ifdef VBOX
    409 static
    410 #endif /* VBOX */
    411 const uint8_t sr_mask[8] = {
     388static const uint8_t sr_mask[8] = {
    412389    (uint8_t)~0xfc,
    413390    (uint8_t)~0xc2,
    … …  
    420397};
    421398
    422 #ifdef VBOX
    423 static
    424 #endif /* VBOX */
    425 const uint8_t gr_mask[16] = {
     399static const uint8_t gr_mask[16] = {
    426400    (uint8_t)~0xf0, /* 0x00 */
    427401    (uint8_t)~0xf0, /* 0x01 */
    … …  
    520494};
    521495
    522 #if defined(VBOX) && defined(IN_RING3)
     496#if defined(IN_RING3)
    523497static uint32_t expand4[256];
    524498static uint16_t expand2[256];
    525499static uint8_t expand4to8[16];
    526 #endif /* VBOX && IN_RING3 */
    527 
    528 #ifndef VBOX
    529 VGAState *vga_state;
    530 int vga_io_memory;
    531 #endif /* !VBOX */
     500#endif /* IN_RING3 */
    532501
    533502static uint32_t vga_ioport_read(void *opaque, uint32_t addr)
    … …  
    650619            index = s->ar_index & 0x1f;
    651620            switch(index) {
    652 #ifndef VBOX
    653             case 0x00 ... 0x0f:
    654 #else /* VBOX */
    655621            case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
    656622            case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f:
    657 #endif /* VBOX */
    658623                s->ar[index] = val & 0x3f;
    659624                break;
    … …  
    892857                s->vbe_regs[s->vbe_index] = val;
    893858            }
    894 #ifdef VBOX
    895859            if (val == VBE_DISPI_ID_VBOX_VIDEO) {
    896860                s->vbe_regs[s->vbe_index] = val;
    … …  
    903867            }
    904868#endif /* VBOX_WITH_HGSMI */
    905 #endif /* VBOX */
    906869            break;
    907870        case VBE_DISPI_INDEX_XRES:
    … …  
    977940                !(s->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED)) {
    978941                int h, shift_control;
    979 #ifdef VBOX
    980942                /* Check the values before we screw up with a resolution which is too big or small. */
    981943                size_t cb = s->vbe_regs[VBE_DISPI_INDEX_XRES];
    … …  
    1004966                }
    1005967#endif  /* KEEP_SCAN_LINE_LENGTH defined */
    1006 #endif /* VBOX */
    1007968
    1008969#ifndef KEEP_SCAN_LINE_LENGTH
    … …  
    1021982                /* clear the screen (should be done in BIOS) */
    1022983                if (!(val & VBE_DISPI_NOCLEARMEM)) {
    1023 #ifndef VBOX
    1024                     memset(s->vram_ptr, 0,
    1025                            s->vbe_regs[VBE_DISPI_INDEX_YRES] * s->vbe_line_offset);
    1026 #else /* VBOX */
    1027984                    memset(s->CTX_SUFF(vram_ptr), 0,
    1028985                           s->vbe_regs[VBE_DISPI_INDEX_YRES] * s->vbe_line_offset);
    1029 #endif /* VBOX */
    1030986                }
    1031987
    … …  
    10571013                s->gr[0x05] = (s->gr[0x05] & ~0x60) | (shift_control << 5);
    10581014                s->cr[0x09] &= ~0x9f; /* no double scan */
    1059 #ifdef VBOX
    10601015                /* sunlover 30.05.2007
    10611016                 * The ar_index remains with bit 0x20 cleared after a switch from fullscreen
    … …  
    10641019                 */
    10651020                s->ar_index |= 0x20;
    1066 #endif /* VBOX */
    10671021            } else {
    10681022                /* XXX: the bios should do that */
    1069 #ifdef VBOX
    10701023                /* sunlover 21.12.2006
    10711024                 * Here is probably more to reset. When this was executed in GC
    … …  
    10781031                 * LFBChange callback.
    10791032                 */
    1080 #endif /* VBOX */
    10811033                s->bank_offset = 0;
    10821034            }
    … …  
    11281080            break;
    11291081        case VBE_DISPI_INDEX_VBOX_VIDEO:
    1130 #ifdef VBOX
    11311082#ifndef IN_RING3
    11321083            return VINF_IOM_HC_IOPORT_WRITE;
    … …  
    11461097            }
    11471098#endif /* IN_RING3 */
    1148 #endif /* VBOX */
    11491099            break;
    11501100        default:
    … …  
    11571107
    11581108/* called for accesses between 0xa0000 and 0xc0000 */
    1159 #ifdef VBOX
    11601109static uint32_t vga_mem_readb(void *opaque, target_phys_addr_t addr, int *prc)
    1161 #else
    1162 uint32_t vga_mem_readb(void *opaque, target_phys_addr_t addr)
    1163 #endif /* VBOX */
    11641110{
    11651111    VGAState *s = (VGAState*)opaque;
    … …  
    11721118    /* convert to VGA memory offset */
    11731119    memory_map_mode = (s->gr[6] >> 2) & 3;
    1174 #ifdef VBOX
    11751120    RTGCPHYS GCPhys = addr; /* save original address */
    1176 #endif
     1121
    11771122    addr &= 0x1ffff;
    11781123    switch(memory_map_mode) {
    … …  
    11991144    if (s->sr[4] & 0x08) {
    12001145        /* chain 4 mode : simplest access */
    1201 #ifndef VBOX
    1202         ret = s->vram_ptr[addr];
    1203 #else /* VBOX */
    12041146# ifndef IN_RC
    12051147        /* If all planes are accessible, then map the page to the frame buffer and make it writable. */
    … …  
    12171159        VERIFY_VRAM_READ_OFF_RETURN(s, addr, *prc);
    12181160        ret = s->CTX_SUFF(vram_ptr)[addr];
    1219 #endif /* VBOX */
    12201161    } else if (!(s->sr[4] & 0x04)) {    /* Host access is controlled by SR4, not GR5! */
    12211162        /* odd/even mode (aka text mode mapping) */
    12221163        plane = (s->gr[4] & 2) | (addr & 1);
    1223 #ifndef VBOX
    1224         ret = s->vram_ptr[((addr & ~1) << 1) | plane];
    1225 #else /* VBOX */
    12261164        /* See the comment for a similar line in vga_mem_writeb. */
    12271165        RTGCPHYS off = ((addr & ~1) << 2) | plane;
    12281166        VERIFY_VRAM_READ_OFF_RETURN(s, off, *prc);
    12291167        ret = s->CTX_SUFF(vram_ptr)[off];
    1230 #endif /* VBOX */
    12311168    } else {
    12321169        /* standard VGA latched access */
    1233 #ifndef VBOX
    1234         s->latch = ((uint32_t *)s->vram_ptr)[addr];
    1235 #else /* VBOX */
    12361170        VERIFY_VRAM_READ_OFF_RETURN(s, addr, *prc);
    12371171        s->latch = ((uint32_t *)s->CTX_SUFF(vram_ptr))[addr];
    1238 #endif /* VBOX */
    12391172
    12401173        if (!(s->gr[5] & 0x08)) {
    … …  
    12561189}
    12571190
    1258 #ifndef VBOX
    1259 static uint32_t vga_mem_readw(void *opaque, target_phys_addr_t addr)
    1260 {
    1261     uint32_t v;
    1262 #ifdef TARGET_WORDS_BIGENDIAN
    1263     v = vga_mem_readb(opaque, addr) << 8;
    1264     v |= vga_mem_readb(opaque, addr + 1);
    1265 #else
    1266     v = vga_mem_readb(opaque, addr);
    1267     v |= vga_mem_readb(opaque, addr + 1) << 8;
    1268 #endif
    1269     return v;
    1270 }
    1271 
    1272 static uint32_t vga_mem_readl(void *opaque, target_phys_addr_t addr)
    1273 {
    1274     uint32_t v;
    1275 #ifdef TARGET_WORDS_BIGENDIAN
    1276     v = vga_mem_readb(opaque, addr) << 24;
    1277     v |= vga_mem_readb(opaque, addr + 1) << 16;
    1278     v |= vga_mem_readb(opaque, addr + 2) << 8;
    1279     v |= vga_mem_readb(opaque, addr + 3);
    1280 #else
    1281     v = vga_mem_readb(opaque, addr);
    1282     v |= vga_mem_readb(opaque, addr + 1) << 8;
    1283     v |= vga_mem_readb(opaque, addr + 2) << 16;
    1284     v |= vga_mem_readb(opaque, addr + 3) << 24;
    1285 #endif
    1286     return v;
    1287 }
    1288 #endif /* !VBOX */
    1289 
    12901191/* called for accesses between 0xa0000 and 0xc0000 */
    1291 #ifdef VBOX
    1292 static
    1293 #endif /* VBOX */
    1294 int vga_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
     1192static int vga_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
    12951193{
    12961194    VGAState *s = (VGAState*)opaque;
    … …  
    13031201    /* convert to VGA memory offset */
    13041202    memory_map_mode = (s->gr[6] >> 2) & 3;
    1305 #ifdef VBOX
    13061203    RTGCPHYS GCPhys = addr; /* save original address */
    1307 #endif
     1204
    13081205    addr &= 0x1ffff;
    13091206    switch(memory_map_mode) {
    … …  
    13331230        mask = (1 << plane);
    13341231        if (s->sr[2] & mask) {
    1335 #ifndef VBOX
    1336             s->vram_ptr[addr] = val;
    1337 #else /* VBOX */
    13381232# ifndef IN_RC
    13391233            /* If all planes are accessible, then map the page to the frame buffer and make it writable. */
    … …  
    13491243            VERIFY_VRAM_WRITE_OFF_RETURN(s, addr);
    13501244            s->CTX_SUFF(vram_ptr)[addr] = val;
    1351 #endif /* VBOX */
    13521245#ifdef DEBUG_VGA_MEM
    13531246            Log(("vga: chain4: [0x%x]\n", addr));
    13541247#endif
    13551248            s->plane_updated |= mask; /* only used to detect font change */
    1356 #ifndef VBOX
    1357             cpu_physical_memory_set_dirty(s->vram_offset + addr);
    1358 #else /* VBOX */
    13591249            vga_set_dirty(s, addr);
    1360 #endif /* VBOX */
    13611250        }
    13621251    } else if (!(s->sr[4] & 0x04)) {    /* Host access is controlled by SR4, not GR5! */
    … …  
    13651254        mask = (1 << plane);
    13661255        if (s->sr[2] & mask) {
    1367 #ifndef VBOX
    1368             addr = ((addr & ~1) << 1) | plane;
    1369 #else
    13701256            /* 'addr' is offset in a plane, bit 0 selects the plane.
    13711257             * Mask the bit 0, convert plane index to vram offset,
    … …  
    13741260             */
    13751261            addr = ((addr & ~1) << 2) | plane;
    1376 #endif /* VBOX */
    1377 #ifndef VBOX
    1378             s->vram_ptr[addr] = val;
    1379 #else /* VBOX */
    13801262            VERIFY_VRAM_WRITE_OFF_RETURN(s, addr);
    13811263            s->CTX_SUFF(vram_ptr)[addr] = val;
    1382 #endif /* VBOX */
    13831264#ifdef DEBUG_VGA_MEM
    13841265            Log(("vga: odd/even: [0x%x]\n", addr));
    13851266#endif
    13861267            s->plane_updated |= mask; /* only used to detect font change */
    1387 #ifndef VBOX
    1388             cpu_physical_memory_set_dirty(s->vram_offset + addr);
    1389 #else /* VBOX */
    13901268            vga_set_dirty(s, addr);
    1391 #endif /* VBOX */
    13921269        }
    13931270    } else {
    … …  
    14971374        s->plane_updated |= mask; /* only used to detect font change */
    14981375        write_mask = mask16[mask];
    1499 #ifndef VBOX
    1500         ((uint32_t *)s->vram_ptr)[addr] =
    1501             (((uint32_t *)s->vram_ptr)[addr] & ~write_mask) |
    1502             (val & write_mask);
    1503 #else /* VBOX */
    15041376        ((uint32_t *)s->CTX_SUFF(vram_ptr))[addr] =
    15051377            (((uint32_t *)s->CTX_SUFF(vram_ptr))[addr] & ~write_mask) |
    15061378            (val & write_mask);
    1507 #endif /* VBOX */
    15081379#ifdef DEBUG_VGA_MEM
    15091380            Log(("vga: latch: [0x%x] mask=0x%08x val=0x%08x\n",
    15101381                   addr * 4, write_mask, val));
    15111382#endif
    1512 #ifndef VBOX
    1513             cpu_physical_memory_set_dirty(s->vram_offset + (addr << 2));
    1514 #else /* VBOX */
    15151383            vga_set_dirty(s, (addr << 2));
    1516 #endif /* VBOX */
    15171384    }
    15181385
    … …  
    15201387}
    15211388
    1522 #ifndef VBOX
    1523 static void vga_mem_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
    1524 {
    1525 #ifdef TARGET_WORDS_BIGENDIAN
    1526     vga_mem_writeb(opaque, addr, (val >> 8) & 0xff);
    1527     vga_mem_writeb(opaque, addr + 1, val & 0xff);
    1528 #else
    1529     vga_mem_writeb(opaque, addr, val & 0xff);
    1530     vga_mem_writeb(opaque, addr + 1, (val >> 8) & 0xff);
    1531 #endif
    1532 }
    1533 
    1534 static void vga_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
    1535 {
    1536 #ifdef TARGET_WORDS_BIGENDIAN
    1537     vga_mem_writeb(opaque, addr, (val >> 24) & 0xff);
    1538     vga_mem_writeb(opaque, addr + 1, (val >> 16) & 0xff);
    1539     vga_mem_writeb(opaque, addr + 2, (val >> 8) & 0xff);
    1540     vga_mem_writeb(opaque, addr + 3, val & 0xff);
    1541 #else
    1542     vga_mem_writeb(opaque, addr, val & 0xff);
    1543     vga_mem_writeb(opaque, addr + 1, (val >> 8) & 0xff);
    1544     vga_mem_writeb(opaque, addr + 2, (val >> 16) & 0xff);
    1545     vga_mem_writeb(opaque, addr + 3, (val >> 24) & 0xff);
    1546 #endif
    1547 }
    1548 #endif /* !VBOX */
    1549 
    1550 #if !defined(VBOX) || defined(IN_RING3)
     1389#if defined(IN_RING3)
    15511390typedef void vga_draw_glyph8_func(uint8_t *d, int linesize,
    15521391                             const uint8_t *font_ptr, int h,
    … …  
    16951534        line_offset = s->cr[0x13];
    16961535        line_offset <<= 3;
    1697 #ifdef VBOX
    16981536        if (!(s->cr[0x14] & 0x40) && !(s->cr[0x17] & 0x40))
    16991537        {
    … …  
    17011539            line_offset *= 2;
    17021540        }
    1703 #endif /* VBOX */
    17041541
    17051542        /* starting address */
    … …  
    18001637 * - flashing
    18011638 */
    1802 #ifndef VBOX
    1803 static void vga_draw_text(VGAState *s, int full_update)
    1804 #else
    18051639static int vga_draw_text(VGAState *s, int full_update, bool fFailOnResize)
    1806 #endif /* !VBOX */
    18071640{
    18081641    int cx, cy, cheight, cw, ch, cattr, height, width, ch_attr;
    … …  
    18281661        full_update = 1;
    18291662    }
    1830 #ifndef VBOX
    1831     font_base[0] = s->vram_ptr + offset;
    1832 #else /* VBOX */
    18331663    font_base[0] = s->CTX_SUFF(vram_ptr) + offset;
    1834 #endif /* VBOX */
    18351664
    18361665    offset = (((v >> 5) & 1) | ((v >> 1) & 6)) * 8192 * 4 + 2;
    1837 #ifndef VBOX
    1838     font_base[1] = s->vram_ptr + offset;
    1839 #else /* VBOX */
    18401666    font_base[1] = s->CTX_SUFF(vram_ptr) + offset;
    1841 #endif /* VBOX */
    18421667    if (offset != s->font_offsets[1]) {
    18431668        s->font_offsets[1] = offset;
    … …  
    18531678
    18541679    line_offset = s->line_offset;
    1855 #ifndef VBOX
    1856     s1 = s->vram_ptr + (s->start_addr * 4);
    1857 #else /* VBOX */
    18581680    s1 = s->CTX_SUFF(vram_ptr) + (s->start_addr * 8); /** @todo r=bird: Add comment why we do *8 instead of *4, it's not so obvious... */
    1859 #endif /* VBOX */
    18601681
    18611682    /* total width & height */
    … …  
    18661687    if (s->sr[1] & 0x08)
    18671688        cw = 16; /* NOTE: no 18 pixel wide */
    1868 #ifndef VBOX
    1869     x_incr = cw * ((s->ds->depth + 7) >> 3);
    1870 #else /* VBOX */
    18711689    x_incr = cw * ((s->pDrv->cBits + 7) >> 3);
    1872 #endif /* VBOX */
    18731690    width = (s->cr[0x01] + 1);
    18741691    if (s->cr[0x06] == 100) {
    … …  
    18831700    if ((height * width) > CH_ATTR_SIZE) {
    18841701        /* better than nothing: exit if transient size is too big */
    1885 #ifndef VBOX
    1886         return;
    1887 #else
    18881702        return VINF_SUCCESS;
    1889 #endif /* VBOX */
    18901703    }
    18911704
    18921705    if (width != (int)s->last_width || height != (int)s->last_height ||
    18931706        cw != s->last_cw || cheight != s->last_ch) {
    1894 #ifdef VBOX
    18951707        if (fFailOnResize)
    18961708        {
    … …  
    18981710            return VERR_TRY_AGAIN;
    18991711        }
    1900 #endif /* VBOX */
    19011712        s->last_scr_width = width * cw;
    19021713        s->last_scr_height = height * cheight;
    1903 #ifndef VBOX
    1904         dpy_resize(s->ds, s->last_scr_width, s->last_scr_height);
    1905         s->last_width = width;
    1906         s->last_height = height;
    1907         s->last_ch = cheight;
    1908         s->last_cw = cw;
    1909         full_update = 1;
    1910 #else /* VBOX */
    19111714        /* For text modes the direct use of guest VRAM is not implemented, so bpp and cbLine are 0 here. */
    19121715        int rc = s->pDrv->pfnResize(s->pDrv, 0, NULL, 0, s->last_scr_width, s->last_scr_height);
    … …  
    19191722            return rc;
    19201723        AssertRC(rc);
    1921 #endif /* VBOX */
    19221724    }
    19231725    cursor_offset = ((s->cr[0x0e] << 8) | s->cr[0x0f]) - s->start_addr;
    … …  
    19351737        s->cursor_end = s->cr[0xb];
    19361738    }
    1937 #ifndef VBOX
    1938     cursor_ptr = s->vram_ptr + (s->start_addr + cursor_offset) * 4;
    1939 
    1940     depth_index = get_depth_index(s->ds->depth);
    1941 #else /* VBOX */
    19421739    cursor_ptr = s->CTX_SUFF(vram_ptr) + (s->start_addr + cursor_offset) * 8;
    19431740    depth_index = get_depth_index(s->pDrv->cBits);
    1944 #endif /* VBOX */
    19451741    if (cw == 16)
    19461742        vga_draw_glyph8 = vga_draw_glyph16_table[depth_index];
    … …  
    19491745    vga_draw_glyph9 = vga_draw_glyph9_table[depth_index];
    19501746
    1951 #ifndef VBOX
    1952     dest = s->ds->data;
    1953     linesize = s->ds->linesize;
    1954 #else /* VBOX */
    19551747    dest = s->pDrv->pu8Data;
    19561748    linesize = s->pDrv->cbScanline;
    1957 #endif /* VBOX */
    19581749    ch_attr_ptr = s->last_ch_attr;
    19591750    cy_start = -1;
    … …  
    20181809            }
    20191810            d1 += x_incr;
    2020 #ifndef VBOX
    2021             src += 4;
    2022 #else
    20231811            src += 8; /* Every second byte of a plane is used in text mode. */
    2024 #endif
    2025 
    20261812            ch_attr_ptr++;
    20271813        }
    2028 #ifndef VBOX
    2029         if (cx_max != -1) {
    2030             dpy_update(s->ds, cx_min * cw, cy * cheight,
    2031                        (cx_max - cx_min + 1) * cw, cheight);
    2032         }
    2033 #else
    20341814        if (cx_max != -1) {
    20351815            /* Keep track of the bounding rectangle for updates. */
    … …  
    20481828            cx_min_upd = width;
    20491829        }
    2050 #endif
    20511830        dest += linesize * cheight;
    20521831        s1 += line_offset;
    20531832    }
    2054 #ifdef VBOX
    20551833    if (cy_start >= 0)
    20561834        /* Flush any remaining changes to display. */
    … …  
    20581836                               (cx_max_upd - cx_min_upd + 1) * cw, (cy - cy_start) * cheight);
    20591837        return VINF_SUCCESS;
    2060 #endif /* VBOX */
    20611838}
    20621839
    … …  
    21611938}
    21621939
    2163 #ifndef VBOX
    2164 void vga_invalidate_scanlines(VGAState *s, int y1, int y2)
    2165 {
    2166     int y;
    2167     if (y1 >= VGA_MAX_HEIGHT)
    2168         return;
    2169     if (y2 >= VGA_MAX_HEIGHT)
    2170         y2 = VGA_MAX_HEIGHT;
    2171     for(y = y1; y < y2; y++) {
    2172         s->invalidated_y_table[y >> 5] |= 1 << (y & 0x1f);
    2173     }
    2174 }
    2175 #endif /* !VBOX*/
    2176 
    2177 #ifdef VBOX
    21781940/**
    21791941 * Performs the display driver resizing when in graphics mode.
    … …  
    22371999    return VINF_SUCCESS;
    22382000}
    2239 #endif /* VBOX */
    22402001
    22412002/*
    22422003 * graphic modes
    22432004 */
    2244 #ifndef VBOX
    2245 static void vga_draw_graphic(VGAState *s, int full_update)
    2246 #else
    22472005static int vga_draw_graphic(VGAState *s, int full_update, bool fFailOnResize)
    2248 #endif /* !VBOX */
    22492006{
    22502007    int y1, y2, y, update, page_min, page_max, linesize, y_start, double_scan;
    … …  
    23222079        }
    23232080    }
    2324 #ifndef VBOX
    2325     vga_draw_line = vga_draw_line_table[v * 4 + get_depth_index(s->ds->depth)];
    2326 
    2327     if (disp_width != s->last_width ||
    2328         height != s->last_height) {
    2329         dpy_resize(s->ds, disp_width, height);
    2330         s->last_scr_width = disp_width;
    2331         s->last_scr_height = height;
    2332         s->last_width = disp_width;
    2333         s->last_height = height;
    2334         full_update = 1;
    2335     }
    2336 #else /* VBOX */
    23372081    if (    disp_width     != (int)s->last_width
    23382082        ||  height         != (int)s->last_height
    … …  
    23522096    vga_draw_line = vga_draw_line_table[v * 4 + get_depth_index(s->pDrv->cBits)];
    23532097
    2354 #endif /* VBOX */
    23552098    if (s->cursor_invalidate)
    23562099        s->cursor_invalidate(s);
    … …  
    23622105#endif
    23632106    addr1 = (s->start_addr * 4);
    2364 #ifndef VBOX
    2365     bwidth = width * 4;
    2366 #else /* VBOX */
    23672107    bwidth = (width * bits + 7) / 8;    /* The visible width of a scanline. */
    2368 #endif /* VBOX */
    23692108    y_start = -1;
    23702109    page_min = 0x7fffffff;
    23712110    page_max = -1;
    2372 #ifndef VBOX
    2373     d = s->ds->data;
    2374     linesize = s->ds->linesize;
    2375 #else /* VBOX */
    23762111    d = s->pDrv->pu8Data;
    23772112    linesize = s->pDrv->cbScanline;
    2378 #endif /* VBOX */
    23792113
    23802114    y1 = 0;
    … …  
    23912125            addr = (addr & ~(1 << 16)) | ((y1 & 2) << 15);
    23922126        }
    2393 #ifndef VBOX
    2394         page0 = s->vram_offset + (addr & TARGET_PAGE_MASK);
    2395         page1 = s->vram_offset + ((addr + bwidth - 1) & TARGET_PAGE_MASK);
    2396         update = full_update |
    2397             cpu_physical_memory_get_dirty(page0, VGA_DIRTY_FLAG) |
    2398             cpu_physical_memory_get_dirty(page1, VGA_DIRTY_FLAG);
    2399         if ((page1 - page0) > TARGET_PAGE_SIZE) {
    2400             /* if wide line, can use another page */
    2401             update |= cpu_physical_memory_get_dirty(page0 + TARGET_PAGE_SIZE,
    2402                                                     VGA_DIRTY_FLAG);
    2403         }
    2404 #else /* VBOX */
    24052127        page0 = addr & TARGET_PAGE_MASK;
    24062128        page1 = (addr + bwidth - 1) & TARGET_PAGE_MASK;
    … …  
    24102132            update |= vga_is_dirty(s, page0 + TARGET_PAGE_SIZE);
    24112133        }
    2412 #endif /* VBOX */
    24132134        /* explicit invalidation for the hardware cursor */
    24142135        update |= (s->invalidated_y_table[y >> 5] >> (y & 0x1f)) & 1;
    … …  
    24202141            if (page1 > page_max)
    24212142                page_max = page1;
    2422 #ifndef VBOX
    2423             vga_draw_line(s, d, s->vram_ptr + addr, width);
    2424 #else /* VBOX */
    24252143            if (s->fRenderVRAM)
    24262144                vga_draw_line(s, d, s->CTX_SUFF(vram_ptr) + addr, width);
    2427 #endif /* VBOX */
    24282145            if (s->cursor_draw_line)
    24292146                s->cursor_draw_line(s, d, y);
    … …  
    24312148            if (y_start >= 0) {
    24322149                /* flush to display */
    2433 #ifndef VBOX
    2434                 dpy_update(s->ds, 0, y_start,
    2435                            disp_width, y - y_start);
    2436 #else /* VBOX */
    24372150                s->pDrv->pfnUpdateRect(s->pDrv, 0, y_start, disp_width, y - y_start);
    2438 #endif /* VBOX */
    24392151                y_start = -1;
    24402152            }
    … …  
    24602172    if (y_start >= 0) {
    24612173        /* flush to display */
    2462 #ifndef VBOX
    2463         dpy_update(s->ds, 0, y_start,
    2464                    disp_width, y - y_start);
    2465 #else /* VBOX */
    24662174        s->pDrv->pfnUpdateRect(s->pDrv, 0, y_start, disp_width, y - y_start);
    2467 #endif /* VBOX */
    24682175    }
    24692176    /* reset modified pages */
    24702177    if (page_max != -1) {
    2471 #ifndef VBOX
    2472         cpu_physical_memory_reset_dirty(page_min, page_max + TARGET_PAGE_SIZE,
    2473                                         VGA_DIRTY_FLAG);
    2474 #else /* VBOX */
    24752178        vga_reset_dirty(s, page_min, page_max + TARGET_PAGE_SIZE);
    2476 #endif /* VBOX */
    24772179    }
    24782180    memset(s->invalidated_y_table, 0, ((height + 31) >> 5) * 4);
    2479 #ifdef VBOX
    24802181    return VINF_SUCCESS;
    2481 #endif /* VBOX */
    24822182}
    24832183
    24842184static void vga_draw_blank(VGAState *s, int full_update)
    24852185{
    2486 #ifndef VBOX
    2487     int i, w, val;
    2488     uint8_t *d;
    2489 
    2490     if (!full_update)
    2491         return;
    2492     if (s->last_scr_width <= 0 || s->last_scr_height <= 0)
    2493         return;
    2494     if (s->ds->depth == 8)
    2495         val = s->rgb_to_pixel(0, 0, 0);
    2496     else
    2497         val = 0;
    2498     w = s->last_scr_width * ((s->ds->depth + 7) >> 3);
    2499     d = s->ds->data;
    2500     for(i = 0; i < s->last_scr_height; i++) {
    2501         memset(d, val, w);
    2502         d += s->ds->linesize;
    2503     }
    2504     dpy_update(s->ds, 0, 0,
    2505                s->last_scr_width, s->last_scr_height);
    2506 #else  /* VBOX */
    2507 
    25082186    int i, w, val;
    25092187    uint8_t *d;
    … …  
    25272205    }
    25282206    s->pDrv->pfnUpdateRect(s->pDrv, 0, 0, s->last_scr_width, s->last_scr_height);
    2529 #endif /* VBOX */
    2530 }
    2531 
    2532 #ifdef VBOX
     2207}
     2208
    25332209static DECLCALLBACK(void) voidUpdateRect(PPDMIDISPLAYCONNECTOR pInterface, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
    25342210{
    25352211}
    2536 #endif /* VBOX */
    25372212
    25382213
    … …  
    25412216#define GMODE_BLANK 2
    25422217
    2543 #ifndef VBOX
    2544 void vga_update_display(void)
    2545 {
    2546     VGAState *s = vga_state;
    2547 #else /* VBOX */
    25482218static int vga_update_display(PVGASTATE s, bool fUpdateAll, bool fFailOnResize)
    25492219{
    25502220    int rc = VINF_SUCCESS;
    2551 #endif /* VBOX */
    25522221    int full_update, graphic_mode;
    25532222
    2554 #ifndef VBOX
    2555     if (s->ds->depth == 0) {
    2556 #else /* VBOX */
    25572223    if (s->pDrv->cBits == 0) {
    2558 #endif /* VBOX */
    25592224        /* nothing to do */
    25602225    } else {
    2561 #ifndef VBOX
    2562         switch(s->ds->depth) {
    2563 #else /* VBOX */
    25642226        switch(s->pDrv->cBits) {
    2565 #endif /* VBOX */
    25662227        case 8:
    25672228            s->rgb_to_pixel = rgb_to_pixel8_dup;
    … …  
    25792240        }
    25802241
    2581 #ifdef VBOX
    25822242        if (fUpdateAll) {
    25832243            /* A full update is requested. Special processing for a "blank" mode is required, because
    … …  
    26252285            return rc;
    26262286        }
    2627 #endif /* VBOX */
    26282287
    26292288        full_update = 0;
    … …  
    26392298        switch(graphic_mode) {
    26402299        case GMODE_TEXT:
    2641 #ifdef VBOX
    2642             rc =
    2643 #endif /* VBOX */
    2644             vga_draw_text(s, full_update, fFailOnResize);
     2300            rc = vga_draw_text(s, full_update, fFailOnResize);
    26452301            break;
    26462302        case GMODE_GRAPH:
    2647 #ifdef VBOX
    2648             rc =
    2649 #endif /* VBOX */
    2650             vga_draw_graphic(s, full_update, fFailOnResize);
     2303            rc = vga_draw_graphic(s, full_update, fFailOnResize);
    26512304            break;
    26522305        case GMODE_BLANK:
    … …  
    26562309        }
    26572310    }
    2658 #ifdef VBOX
    26592311    return rc;
    2660 #endif /* VBOX */
    2661 }
    2662 
    2663 /* force a full display refresh */
    2664 #ifndef VBOX
    2665 void vga_invalidate_display(void)
    2666 {
    2667     VGAState *s = vga_state;
    2668 
    2669     s->last_width = -1;
    2670     s->last_height = -1;
    2671 }
    2672 #endif /* !VBOX */
    2673 
    2674 #ifndef VBOX /* see vgaR3Reset() */
    2675 static void vga_reset(VGAState *s)
    2676 {
    2677     memset(s, 0, sizeof(VGAState));
    2678     s->graphic_mode = -1; /* force full update */
    2679 }
    2680 #endif /* !VBOX */
    2681 
    2682 #ifndef VBOX
    2683 static CPUReadMemoryFunc *vga_mem_read[3] = {
    2684     vga_mem_readb,
    2685     vga_mem_readw,
    2686     vga_mem_readl,
    2687 };
    2688 
    2689 static CPUWriteMemoryFunc *vga_mem_write[3] = {
    2690     vga_mem_writeb,
    2691     vga_mem_writew,
    2692     vga_mem_writel,
    2693 };
    2694 #endif /* !VBOX */
     2312}
    26952313
    26962314static void vga_save(QEMUFile *f, void *opaque)
    … …  
    27402358    uint32_t u32Dummy;
    27412359
    2742 #ifndef VBOX /* checked by the caller. */
    2743     if (version_id > VGA_SAVEDSTATE_VERSION)
    2744         return -EINVAL;
    2745 #endif /* VBOX */
    2746 
    27472360    qemu_get_be32s(f, &s->latch);
    27482361    qemu_get_8s(f, &s->sr_index);
    … …  
    27712384#ifdef CONFIG_BOCHS_VBE
    27722385    if (!is_vbe)
    2773 # ifndef VBOX
    2774         return -EINVAL;
    2775 # else /* VBOX */
    27762386    {
    27772387        Log(("vga_load: !is_vbe !!\n"));
    27782388        return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
    27792389    }
    2780 # endif /* VBOX */
    27812390    qemu_get_be16s(f, &s->vbe_index);
    27822391    for(i = 0; i < VBE_DISPI_INDEX_NB_SAVED; i++)
    … …  
    27892398#else
    27902399    if (is_vbe)
    2791 # ifndef VBOX
    2792         return -EINVAL;
    2793 # else /* VBOX */
    27942400    {
    27952401        Log(("vga_load: is_vbe !!\n"));
    27962402        return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
    27972403    }
    2798 # endif /* VBOX */
    27992404#endif
    28002405
    … …  
    28042409}
    28052410
    2806 #ifndef VBOX /* see vgaR3IORegionMap */
    2807 static void vga_map(PCIDevice *pci_dev, int region_num,
    2808                     uint32_t addr, uint32_t size, int type)
    2809 {
    2810     VGAState *s = vga_state;
    2811 
    2812     cpu_register_physical_memory(addr, s->vram_size, s->vram_offset);
    2813 }
    2814 #endif
    2815 
    2816 #ifndef VBOX /* see vgaR3Construct */
    2817 void vga_common_init(VGAState *s, DisplayState *ds, uint8_t *vga_ram_base,
    2818                      unsigned long vga_ram_offset, int vga_ram_size)
    2819 #else
     2411/* see vgaR3Construct */
    28202412static void vga_init_expand(void)
    2821 #endif
    28222413{
    28232414    int i, j, v, b;
    … …  
    28452436        expand4to8[i] = v;
    28462437    }
    2847 #ifdef VBOX
    2848 }
    2849 #else /* !VBOX */
    2850     vga_reset(s);
    2851 
    2852     s->vram_ptr = vga_ram_base;
    2853     s->vram_offset = vga_ram_offset;
    2854     s->vram_size = vga_ram_size;
    2855     s->ds = ds;
    2856     s->get_bpp = vga_get_bpp;
    2857     s->get_offsets = vga_get_offsets;
    2858     s->get_resolution = vga_get_resolution;
    2859     /* XXX: currently needed for display */
    2860     vga_state = s;
    2861 }
    2862 
    2863 
    2864 int vga_initialize(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
    2865                    unsigned long vga_ram_offset, int vga_ram_size)
    2866 {
    2867     VGAState *s;
    2868 
    2869     s = qemu_mallocz(sizeof(VGAState));
    2870     if (!s)
    2871         return -1;
    2872 
    2873     vga_common_init(s, ds, vga_ram_base, vga_ram_offset, vga_ram_size);
    2874 
    2875     register_savevm("vga", 0, 1, vga_save, vga_load, s);
    2876 
    2877     register_ioport_write(0x3c0, 16, 1, vga_ioport_write, s);
    2878 
    2879     register_ioport_write(0x3b4, 2, 1, vga_ioport_write, s);
    2880     register_ioport_write(0x3d4, 2, 1, vga_ioport_write, s);
    2881     register_ioport_write(0x3ba, 1, 1, vga_ioport_write, s);
    2882     register_ioport_write(0x3da, 1, 1, vga_ioport_write, s);
    2883 
    2884     register_ioport_read(0x3c0, 16, 1, vga_ioport_read, s);
    2885 
    2886     register_ioport_read(0x3b4, 2, 1, vga_ioport_read, s);
    2887     register_ioport_read(0x3d4, 2, 1, vga_ioport_read, s);
    2888     register_ioport_read(0x3ba, 1, 1, vga_ioport_read, s);
    2889     register_ioport_read(0x3da, 1, 1, vga_ioport_read, s);
    2890     s->bank_offset = 0;
    2891 
    2892 #ifdef CONFIG_BOCHS_VBE
    2893     s->vbe_regs[VBE_DISPI_INDEX_ID] = VBE_DISPI_ID0;
    2894     s->vbe_bank_max = (s->vram_size >> 16) - 1;
    2895 #if defined (TARGET_I386)
    2896     register_ioport_read(0x1ce, 1, 2, vbe_ioport_read_index, s);
    2897     register_ioport_read(0x1cf, 1, 2, vbe_ioport_read_data, s);
    2898 
    2899     register_ioport_write(0x1ce, 1, 2, vbe_ioport_write_index, s);
    2900     register_ioport_write(0x1cf, 1, 2, vbe_ioport_write_data, s);
    2901 
    2902     /* old Bochs IO ports */
    2903     register_ioport_read(0xff80, 1, 2, vbe_ioport_read_index, s);
    2904     register_ioport_read(0xff81, 1, 2, vbe_ioport_read_data, s);
    2905 
    2906     register_ioport_write(0xff80, 1, 2, vbe_ioport_write_index, s);
    2907     register_ioport_write(0xff81, 1, 2, vbe_ioport_write_data, s);
    2908 #else
    2909     register_ioport_read(0x1ce, 1, 2, vbe_ioport_read_index, s);
    2910     register_ioport_read(0x1d0, 1, 2, vbe_ioport_read_data, s);
    2911 
    2912     register_ioport_write(0x1ce, 1, 2, vbe_ioport_write_index, s);
    2913     register_ioport_write(0x1d0, 1, 2, vbe_ioport_write_data, s);
    2914 #endif
    2915 #endif /* CONFIG_BOCHS_VBE */
    2916 
    2917     vga_io_memory = cpu_register_io_memory(0, vga_mem_read, vga_mem_write, s);
    2918     cpu_register_physical_memory(isa_mem_base + 0x000a0000, 0x20000,
    2919                                  vga_io_memory);
    2920 
    2921     if (bus) {
    2922         PCIDevice *d;
    2923         uint8_t *pci_conf;
    2924 
    2925         d = pci_register_device(bus, "VGA",
    2926                                 sizeof(PCIDevice),
    2927                                 -1, NULL, NULL);
    2928         pci_conf = d->config;
    2929         pci_conf[0x00] = 0x34; // dummy VGA (same as Bochs ID)
    2930         pci_conf[0x01] = 0x12;
    2931         pci_conf[0x02] = 0x11;
    2932         pci_conf[0x03] = 0x11;
    2933         pci_conf[0x0a] = 0x00; // VGA controller
    2934         pci_conf[0x0b] = 0x03;
    2935         pci_conf[0x0e] = 0x00; // header_type
    2936 
    2937         /* XXX: vga_ram_size must be a power of two */
    2938         pci_register_io_region(d, 0, vga_ram_size,
    2939                                PCI_ADDRESS_SPACE_MEM_PREFETCH, vga_map);
    2940     } else {
    2941 #ifdef CONFIG_BOCHS_VBE
    2942         /* XXX: use optimized standard vga accesses */
    2943         cpu_register_physical_memory(VBE_DISPI_LFB_PHYSICAL_ADDRESS,
    2944                                      vga_ram_size, vga_ram_offset);
    2945 #endif
    2946     }
    2947     return 0;
    2948 }
    2949 #endif /* !VBOX */
    2950 
    2951 #endif /* !VBOX || !IN_RC || !IN_RING0 */
    2952 
    2953 
    2954 
    2955 #ifdef VBOX /* VirtualBox code start */
     2438}
     2439
     2440#endif /* !IN_RING0 */
     2441
    29562442
    29572443
    … …  
    52554741    if (x + w > s->pDrv->cx)
    52564742    {
    5257 #ifndef VBOX
    5258         w = s->pDrv->cx > x? s->pDrv->cx - x: 0;
    5259 #else
    52604743        // x < 0 is not possible here
    52614744        w = s->pDrv->cx > (uint32_t)x? s->pDrv->cx - x: 0;
    5262 #endif
    52634745    }
    52644746
    52654747    if (y + h > s->pDrv->cy)
    52664748    {
    5267 #ifndef VBOX
    5268         h = s->pDrv->cy > y? s->pDrv->cy - y: 0;
    5269 #else
    52704749        // y < 0 is not possible here
    52714750        h = s->pDrv->cy > (uint32_t)y? s->pDrv->cy - y: 0;
    5272 #endif
    52734751    }
    52744752
    … …  
    57985276                    RTLogPrintf("%c", ch);
    57995277
    5800 #ifndef VBOX
    5801                     src += 4;
    5802 #else
    58035278                    src += 8; /* Every second byte of a plane is used in text mode. */
    5804 #endif
    58055279                }
    58065280                if (cx_max != -1)
    … …  
    62945768    if (RT_FAILURE(rc))
    62955769        return rc;
    6296 #if 0
    6297     /* This now causes conflicts with Win2k & XP; it is not aware this range is taken
    6298        and tries to map other devices there */
    6299     /* Old Bochs. */
    6300     rc = PDMDevHlpIOPortRegister(pDevIns, 0xff80,  1, NULL, vgaIOPortWriteVBEIndex, vgaIOPortReadVBEIndex, "VGA/VBE - Index Old");
    6301     if (RT_FAILURE(rc))
    6302         return rc;
    6303     rc = PDMDevHlpIOPortRegister(pDevIns, 0xff81,  1, NULL, vgaIOPortWriteVBEData, vgaIOPortReadVBEData, "VGA/VBE - Data Old");
    6304     if (RT_FAILURE(rc))
    6305         return rc;
    6306 #endif
    63075770#endif /* CONFIG_BOCHS_VBE */
    63085771
    … …  
    63325795        if (RT_FAILURE(rc))
    63335796            return rc;
    6334 
    6335 #if 0
    6336         /* This now causes conflicts with Win2k & XP; they are not aware this range is taken
    6337            and try to map other devices there */
    6338         /* Old Bochs. */
    6339         rc = PDMDevHlpIOPortRegisterRC(pDevIns, 0xff80,  1, 0, "vgaIOPortWriteVBEIndex", "vgaIOPortReadVBEIndex", "VGA/VBE - Index Old (GC)");
    6340         if (RT_FAILURE(rc))
    6341             return rc;
    6342         rc = PDMDevHlpIOPortRegisterRC(pDevIns, 0xff81,  1, 0, "vgaIOPortWriteVBEData", "vgaIOPortReadVBEData", "VGA/VBE - Index Old (GC)");
    6343         if (RT_FAILURE(rc))
    6344             return rc;
    6345 #endif
    6346 
    63475797#endif /* CONFIG_BOCHS_VBE */
    63485798    }
    … …  
    63735823        if (RT_FAILURE(rc))
    63745824            return rc;
    6375 
    6376 #if 0
    6377         /* This now causes conflicts with Win2k & XP; they are not aware this range is taken
    6378            and try to map other devices there */
    6379         /* Old Bochs. */
    6380         rc = PDMDevHlpIOPortRegisterR0(pDevIns, 0xff80,  1, 0, "vgaIOPortWriteVBEIndex", "vgaIOPortReadVBEIndex", "VGA/VBE - Index Old (GC)");
    6381         if (RT_FAILURE(rc))
    6382             return rc;
    6383         rc = PDMDevHlpIOPortRegisterR0(pDevIns, 0xff81,  1, 0, "vgaIOPortWriteVBEData", "vgaIOPortReadVBEData", "VGA/VBE - Index Old (GC)");
    6384         if (RT_FAILURE(rc))
    6385             return rc;
    6386 #endif
    6387 
    63885825#endif /* CONFIG_BOCHS_VBE */
    63895826    }
    … …  
    70106447
    70116448#endif /* !IN_RING3 */
    7012 #endif /* VBOX */
    70136449#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
    70146450
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette