← Back to branch summary

~ubuntu-branches/ubuntu/precise/mame/precise-proposed

« back to all changes in this revision

Viewing changes to src/emu/video/pc_vga.c

  • Committer: Bazaar Package Importer
  • Author(s): Cesare Falco
  • Date: 2010-08-01 23:18:31 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100801231831-9dj2qbsynutixsoe
Tags: 0.139-0ubuntu1
https://launchpad.net/bugs/612070
* New upstream release (LP: #612070)
* debian/contrib/manpages: removed, accepted upstream
* debian/patches/:
  - deprecated_gtk_macros: removed, fixed upstream
  - missing_newline.patch: removed, fixed upstream
  - typos.patch: removed, fixed upstream
* debian/rules: new variables SYMLEVEL and DUMPSYM
* mame-tools: ldplayer removed, possibly for good (FTBFS upstream)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/emu/video/pc_vga.c
 
1
/***************************************************************************
 
2
 
 
3
    Video Graphics Adapter (VGA) section
 
4
 
 
5
    Nathan Woods    npwoods@mess.org
 
6
    Peter Trauner   PeT mess@utanet.at
 
7
 
 
8
    This code takes care of installing the various VGA memory and port
 
9
    handlers
 
10
 
 
11
    The VGA standard is compatible with MDA, CGA, Hercules, EGA
 
12
    (mda, cga, hercules not real register compatible)
 
13
    several vga cards drive also mda, cga, ega monitors
 
14
    some vga cards have register compatible mda, cga, hercules modes
 
15
 
 
16
    ega/vga
 
17
    64k (early ega 16k) words of 32 bit memory
 
18
 
 
19
 
 
20
    ROM declarations:
 
21
 
 
22
    (oti 037 chip)
 
23
    ROM_LOAD("oakvga.bin", 0xc0000, 0x8000, 0x318c5f43)
 
24
    (tseng labs famous et4000 isa vga card (oem))
 
25
    ROM_LOAD("et4000b.bin", 0xc0000, 0x8000, 0xa903540d)
 
26
    (tseng labs famous et4000 isa vga card)
 
27
    ROM_LOAD("et4000.bin", 0xc0000, 0x8000, 0xf01e4be0)
 
28
 
 
29
***************************************************************************/
 
30
 
 
31
#include "emu.h"
 
32
#include "pc_vga.h"
 
33
#include "pc_video.h"
 
34
 
 
35
#include "memconv.h"
 
36
 
 
37
/***************************************************************************
 
38
 
 
39
    Static declarations
 
40
 
 
41
***************************************************************************/
 
42
 
 
43
#define LOG_ACCESSES    0
 
44
#define LOG_REGISTERS   0
 
45
 
 
46
static const char* vga_crtc_reg_names[] =
 
47
{
 
48
        "Horizontal Total Register",
 
49
        "End Horizontal Display Register",
 
50
        "Start Horizontal Blanking Register",
 
51
        "End Horizontal Blanking Register",
 
52
        "Start Horizontal Retrace Register",
 
53
        "End Horizontal Retrace Register",
 
54
        "Vertical Total Register",
 
55
        "Overflow Register",
 
56
        "Preset Row Scan Register",
 
57
        "Maximum Scan Line Register",
 
58
        "Cursor Start Register",
 
59
        "Cursor End Register",
 
60
        "Start Address High Register",
 
61
        "Start Address Low Register",
 
62
        "Cursor Location High Register",
 
63
        "Cursor Location Low Register",
 
64
        "Vertical Retrace Start Register",
 
65
        "Vertical Retrace End Register",
 
66
        "Vertical Display End Register",
 
67
        "Offset Register",
 
68
        "Underline Location Register",
 
69
        "Start Vertical Blanking Register",
 
70
        "End Vertical Blanking",
 
71
        "CRTC Mode Control Register",
 
72
        "Line Compare Register"
 
73
};
 
74
 
 
75
 
 
76
static PALETTE_INIT( ega );
 
77
static PALETTE_INIT( vga );
 
78
static VIDEO_START( ega );
 
79
static VIDEO_START( vga );
 
80
static VIDEO_RESET( ega );
 
81
static VIDEO_RESET( vga );
 
82
 
 
83
static pc_video_update_proc pc_vga_choosevideomode(running_machine *machine, int *width, int *height);
 
84
static pc_video_update_proc pc_ega_choosevideomode(running_machine *machine, int *width, int *height);
 
85
 
 
86
/***************************************************************************
 
87
 
 
88
    MachineDriver stuff
 
89
 
 
90
***************************************************************************/
 
91
 
 
92
/* grabbed from dac inited by et4000 bios */
 
93
static const unsigned char ega_palette[] =
 
94
{
 
95
        0x00, 0x00, 0x00,
 
96
        0x00, 0x00, 0xa8,
 
97
        0x00, 0xa8, 0x00,
 
98
        0x00, 0xa8, 0xa8,
 
99
        0xa8, 0x00, 0x00,
 
100
        0xa8, 0x00, 0xa8,
 
101
        0xa8, 0x54, 0x00,
 
102
        0xa8, 0xa8, 0xa8,
 
103
        0x00, 0x00, 0x00,
 
104
        0x00, 0x00, 0xa8,
 
105
        0x00, 0xa8, 0x00,
 
106
        0x00, 0xa8, 0xa8,
 
107
        0xa8, 0x00, 0x00,
 
108
        0xa8, 0x00, 0xa8,
 
109
        0xa8, 0x54, 0x00,
 
110
        0xa8, 0xa8, 0xa8,
 
111
        0x54, 0x54, 0x54,
 
112
        0x54, 0x54, 0xfc,
 
113
        0x54, 0xfc, 0x54,
 
114
        0x54, 0xfc, 0xfc,
 
115
        0xfc, 0x54, 0x54,
 
116
        0xfc, 0x54, 0xfc,
 
117
        0xfc, 0xfc, 0x54,
 
118
        0xfc, 0xfc, 0xfc,
 
119
        0x54, 0x54, 0x54,
 
120
        0x54, 0x54, 0xfc,
 
121
        0x54, 0xfc, 0x54,
 
122
        0x54, 0xfc, 0xfc,
 
123
        0xfc, 0x54, 0x54,
 
124
        0xfc, 0x54, 0xfc,
 
125
        0xfc, 0xfc, 0x54,
 
126
        0xfc, 0xfc, 0xfc,
 
127
        0x00, 0x00, 0x00,
 
128
        0x00, 0x00, 0xa8,
 
129
        0x00, 0xa8, 0x00,
 
130
        0x00, 0xa8, 0xa8,
 
131
        0xa8, 0x00, 0x00,
 
132
        0xa8, 0x00, 0xa8,
 
133
        0xa8, 0x54, 0x00,
 
134
        0xa8, 0xa8, 0xa8,
 
135
        0x00, 0x00, 0x00,
 
136
        0x00, 0x00, 0xa8,
 
137
        0x00, 0xa8, 0x00,
 
138
        0x00, 0xa8, 0xa8,
 
139
        0xa8, 0x00, 0x00,
 
140
        0xa8, 0x00, 0xa8,
 
141
        0xa8, 0x54, 0x00,
 
142
        0xa8, 0xa8, 0xa8,
 
143
        0x54, 0x54, 0x54,
 
144
        0x54, 0x54, 0xfc,
 
145
        0x54, 0xfc, 0x54,
 
146
        0x54, 0xfc, 0xfc,
 
147
        0xfc, 0x54, 0x54,
 
148
        0xfc, 0x54, 0xfc,
 
149
        0xfc, 0xfc, 0x54,
 
150
        0xfc, 0xfc, 0xfc,
 
151
        0x54, 0x54, 0x54,
 
152
        0x54, 0x54, 0xfc,
 
153
        0x54, 0xfc, 0x54,
 
154
        0x54, 0xfc, 0xfc,
 
155
        0xfc, 0x54, 0x54,
 
156
        0xfc, 0x54, 0xfc,
 
157
        0xfc, 0xfc, 0x54,
 
158
        0xfc, 0xfc, 0xfc
 
159
};
 
160
 
 
161
static const unsigned short vga_colortable[] =
 
162
{
 
163
     0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0,10, 0,11, 0,12, 0,13, 0,14, 0,15,
 
164
     1, 0, 1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1,10, 1,11, 1,12, 1,13, 1,14, 1,15,
 
165
     2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5, 2, 6, 2, 7, 2, 8, 2, 9, 2,10, 2,11, 2,12, 2,13, 2,14, 2,15,
 
166
     3, 0, 3, 1, 3, 2, 3, 3, 3, 4, 3, 5, 3, 6, 3, 7, 3, 8, 3, 9, 3,10, 3,11, 3,12, 3,13, 3,14, 3,15,
 
167
     4, 0, 4, 1, 4, 2, 4, 3, 4, 4, 4, 5, 4, 6, 4, 7, 4, 8, 4, 9, 4,10, 4,11, 4,12, 4,13, 4,14, 4,15,
 
168
     5, 0, 5, 1, 5, 2, 5, 3, 5, 4, 5, 5, 5, 6, 5, 7, 5, 8, 5, 9, 5,10, 5,11, 5,12, 5,13, 5,14, 5,15,
 
169
     6, 0, 6, 1, 6, 2, 6, 3, 6, 4, 6, 5, 6, 6, 6, 7, 6, 8, 6, 9, 6,10, 6,11, 6,12, 6,13, 6,14, 6,15,
 
170
     7, 0, 7, 1, 7, 2, 7, 3, 7, 4, 7, 5, 7, 6, 7, 7, 7, 8, 7, 9, 7,10, 7,11, 7,12, 7,13, 7,14, 7,15,
 
171
/* flashing is done by dirtying the videoram buffer positions with attr bit #7 set */
 
172
     8, 0, 8, 1, 8, 2, 8, 3, 8, 4, 8, 5, 8, 6, 8, 7, 8, 8, 8, 9, 8,10, 8,11, 8,12, 8,13, 8,14, 8,15,
 
173
     9, 0, 9, 1, 9, 2, 9, 3, 9, 4, 9, 5, 9, 6, 9, 7, 9, 8, 9, 9, 9,10, 9,11, 9,12, 9,13, 9,14, 9,15,
 
174
    10, 0,10, 1,10, 2,10, 3,10, 4,10, 5,10, 6,10, 7,10, 8,10, 9,10,10,10,11,10,12,10,13,10,14,10,15,
 
175
    11, 0,11, 1,11, 2,11, 3,11, 4,11, 5,11, 6,11, 7,11, 8,11, 9,11,10,11,11,11,12,11,13,11,14,11,15,
 
176
    12, 0,12, 1,12, 2,12, 3,12, 4,12, 5,12, 6,12, 7,12, 8,12, 9,12,10,12,11,12,12,12,13,12,14,12,15,
 
177
    13, 0,13, 1,13, 2,13, 3,13, 4,13, 5,13, 6,13, 7,13, 8,13, 9,13,10,13,11,13,12,13,13,13,14,13,15,
 
178
    14, 0,14, 1,14, 2,14, 3,14, 4,14, 5,14, 6,14, 7,14, 8,14, 9,14,10,14,11,14,12,14,13,14,14,14,15,
 
179
    15, 0,15, 1,15, 2,15, 3,15, 4,15, 5,15, 6,15, 7,15, 8,15, 9,15,10,15,11,15,12,15,13,15,14,15,15
 
180
};
 
181
 
 
182
MACHINE_DRIVER_START( pcvideo_vga )
 
183
        MDRV_SCREEN_ADD("screen", RASTER)
 
184
        MDRV_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
 
185
        MDRV_SCREEN_SIZE(720, 480)
 
186
        MDRV_SCREEN_VISIBLE_AREA(0,720-1, 0,480-1)
 
187
        MDRV_PALETTE_LENGTH(0x100)
 
188
        MDRV_PALETTE_INIT(vga)
 
189
 
 
190
        MDRV_VIDEO_START(vga)
 
191
        MDRV_VIDEO_RESET(vga)
 
192
        MDRV_VIDEO_UPDATE(pc_video)
 
193
MACHINE_DRIVER_END
 
194
 
 
195
MACHINE_DRIVER_START( pcvideo_pc1640 )
 
196
        MDRV_SCREEN_ADD("screen", RASTER)
 
197
        MDRV_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
 
198
        MDRV_SCREEN_SIZE(720, 350)
 
199
        MDRV_SCREEN_VISIBLE_AREA(0,720-1, 0,350-1)
 
200
        MDRV_PALETTE_LENGTH(sizeof(ega_palette) / 3)
 
201
        MDRV_PALETTE_INIT(ega)
 
202
 
 
203
        MDRV_VIDEO_START(ega)
 
204
        MDRV_VIDEO_RESET(ega)
 
205
        MDRV_VIDEO_UPDATE(pc_video)
 
206
MACHINE_DRIVER_END
 
207
 
 
208
/***************************************************************************/
 
209
 
 
210
static PALETTE_INIT( ega )
 
211
{
 
212
        int i;
 
213
 
 
214
        for ( i = 0; i < sizeof(ega_palette) / 3; i++ ) {
 
215
                palette_set_color_rgb(machine, i, ega_palette[i*3], ega_palette[i*3+1], ega_palette[i*3+2]);
 
216
        }
 
217
}
 
218
 
 
219
static PALETTE_INIT( vga )
 
220
{
 
221
        int i;
 
222
        for (i = 0; i < 0x100; i++)
 
223
                palette_set_color_rgb(machine, i, 0, 0, 0);
 
224
}
 
225
 
 
226
static UINT8 color_bitplane_to_packed[4/*plane*/][8/*pixel*/][256];
 
227
 
 
228
static struct
 
229
{
 
230
        struct pc_vga_interface vga_intf;
 
231
        struct pc_svga_interface svga_intf;
 
232
 
 
233
        UINT8 *memory;
 
234
        UINT8 *fontdirty;
 
235
        UINT16 pens[16]; /* the current 16 pens */
 
236
 
 
237
        UINT8 miscellaneous_output;
 
238
        UINT8 feature_control;
 
239
        UINT16 line_compare;  // for split-screen use.
 
240
 
 
241
        struct
 
242
        {
 
243
                UINT8 index;
 
244
                UINT8 *data;
 
245
        } sequencer;
 
246
        struct
 
247
        {
 
248
                UINT8 index;
 
249
                UINT8 *data;
 
250
        } crtc;
 
251
        struct
 
252
        {
 
253
                UINT8 index;
 
254
                UINT8 *data;
 
255
                UINT8 latch[4];
 
256
        } gc;
 
257
        struct { UINT8 index, data[0x15]; int state; } attribute;
 
258
 
 
259
 
 
260
        struct {
 
261
                UINT8 read_index, write_index, mask;
 
262
                int read;
 
263
                int state;
 
264
                struct { UINT8 red, green, blue; } color[0x100];
 
265
                int dirty;
 
266
        } dac;
 
267
 
 
268
        struct {
 
269
                int time;
 
270
                int visible;
 
271
        } cursor;
 
272
 
 
273
        struct {
 
274
                int (*get_clock)(void);
 
275
 
 
276
                int (*get_lines)(void);
 
277
                int (*get_sync_lines)(void);
 
278
 
 
279
                int (*get_columns)(void);
 
280
                int (*get_sync_columns)(void);
 
281
 
 
282
                attotime start_time;
 
283
                int retrace;
 
284
        } monitor;
 
285
 
 
286
        /* oak vga */
 
287
        struct { UINT8 reg; } oak;
 
288
 
 
289
        int log;
 
290
} vga;
 
291
 
 
292
 
 
293
// to use the mscrtc6845 macros
 
294
#define REG(x) vga.crtc.data[x]
 
295
 
 
296
#define DOUBLESCAN ((vga.crtc.data[9]&0x80)||((vga.crtc.data[9]&0x1f)!=0) )
 
297
#define CRTC_PORT_ADDR ((vga.miscellaneous_output&1)?0x3d0:0x3b0)
 
298
 
 
299
#define CRTC_ON (vga.crtc.data[0x17]&0x80)
 
300
 
 
301
#define LINES_HELPER ( (vga.crtc.data[0x12] \
 
302
                                |((vga.crtc.data[7]&2)<<7) \
 
303
                                |((vga.crtc.data[7]&0x40)<<3))+1 )
 
304
//#define TEXT_LINES (LINES_HELPER)
 
305
#define LINES (DOUBLESCAN?LINES_HELPER>>1:LINES_HELPER)
 
306
#define TEXT_LINES (LINES_HELPER >> ((vga.crtc.data[9]&0x80) ? 1 : 0))
 
307
 
 
308
#define GRAPHIC_MODE (vga.gc.data[6]&1) /* else textmodus */
 
309
 
 
310
#define EGA_COLUMNS (vga.crtc.data[1]+1)
 
311
#define EGA_START_ADDRESS ((vga.crtc.data[0xd]|(vga.crtc.data[0xc]<<8))<<2)
 
312
#define EGA_LINE_LENGTH (vga.crtc.data[0x13]<<3)
 
313
 
 
314
#define VGA_COLUMNS (EGA_COLUMNS>>1)
 
315
#define VGA_START_ADDRESS (EGA_START_ADDRESS)
 
316
#define VGA_LINE_LENGTH (EGA_LINE_LENGTH<<2)
 
317
 
 
318
#define CHAR_WIDTH ((vga.sequencer.data[1]&1)?8:9)
 
319
//#define CHAR_HEIGHT ((vga.crtc.data[9]&0x1f)+1)
 
320
 
 
321
#define TEXT_COLUMNS (vga.crtc.data[1]+1)
 
322
#define TEXT_START_ADDRESS (EGA_START_ADDRESS)
 
323
#define TEXT_LINE_LENGTH (EGA_LINE_LENGTH>>2)
 
324
 
 
325
#define TEXT_COPY_9COLUMN(ch) ( (ch>=192)&&(ch<=223)&&(vga.attribute.data[0x10]&4))
 
326
 
 
327
//#define CURSOR_ON (!(vga.crtc.data[0xa]&0x20))
 
328
//#define CURSOR_STARTLINE (vga.crtc.data[0xa]&0x1f)
 
329
//#define CURSOR_ENDLINE (vga.crtc.data[0xb]&0x1f)
 
330
//#define CURSOR_POS (vga.crtc.data[0xf]|(vga.crtc.data[0xe]<<8))
 
331
 
 
332
#define FONT1 ( ((vga.sequencer.data[3]&3)|((vga.sequencer.data[3]&0x10)<<2))*0x2000)
 
333
#define FONT2 ((((vga.sequencer.data[3]&c)>>2)|((vga.sequencer.data[3]&0x20)<<3))*0x2000)
 
334
 
 
335
#define CRTC6845_COLUMNS (REG(0)+1)
 
336
#define CRTC6845_CHAR_COLUMNS (REG(1))
 
337
#define CRTC6845_LINES (REG(4)*CRTC6845_CHAR_HEIGHT+REG(5))
 
338
#define CRTC6845_CHAR_LINES REG(6)
 
339
#define CRTC6845_CHAR_HEIGHT ((REG(9)&0x1f)+1)
 
340
#define CRTC6845_VIDEO_START ((REG(0xc)<<8)|REG(0xd))
 
341
#define CRTC6845_INTERLACE_MODE (REG(8)&3)
 
342
#define CRTC6845_INTERLACE_SIGNAL 1
 
343
#define CRTC6845_INTERLACE 3
 
344
#define CRTC6845_CURSOR_MODE (REG(0xa)&0x60)
 
345
#define CRTC6845_CURSOR_OFF 0x20
 
346
#define CRTC6845_CURSOR_16FRAMES 0x40
 
347
#define CRTC6845_CURSOR_32FRAMES 0x60
 
348
#define CRTC6845_SKEW   (REG(8)&15)
 
349
#define CRTC6845_CURSOR_POS ((REG(0xe)<<8)|REG(0xf))
 
350
#define CRTC6845_CURSOR_TOP     (REG(0xa)&0x1f)
 
351
#define CRTC6845_CURSOR_BOTTOM REG(0xb)
 
352
 
 
353
INLINE UINT8 rotate_right(UINT8 val, UINT8 rot)
 
354
{
 
355
        return (val >> rot) | (val << (8 - rot));
 
356
}
 
357
 
 
358
 
 
359
 
 
360
static int ega_get_clock(void)
 
361
{
 
362
        int clck=0;
 
363
        switch(vga.miscellaneous_output&0xc) {
 
364
        case 0: clck=14000000;break;
 
365
        case 4: clck=16000000;break;
 
366
        /* case 8: external */
 
367
        /* case 0xc: reserved */
 
368
        }
 
369
        if (vga.sequencer.data[1]&8) clck/=2;
 
370
        return clck;
 
371
}
 
372
 
 
373
static int vga_get_clock(void)
 
374
{
 
375
        int clck=0;
 
376
        switch(vga.miscellaneous_output&0xc) {
 
377
        case 0: clck=25000000;break;
 
378
        case 4: clck=28000000;break;
 
379
        /* case 8: external */
 
380
        /* case 0xc: reserved */
 
381
        }
 
382
        if (vga.sequencer.data[1]&8) clck/=2;
 
383
        return clck;
 
384
}
 
385
 
 
386
static int ega_get_crtc_columns(void) /* in clocks! */
 
387
{
 
388
        int columns=vga.crtc.data[0]+2;
 
389
        if (!GRAPHIC_MODE) {
 
390
                columns*=CHAR_WIDTH;
 
391
        } else {
 
392
                columns*=8;
 
393
        }
 
394
        return columns;
 
395
}
 
396
 
 
397
static int ega_get_crtc_lines(void)
 
398
{
 
399
        int lines=vga.crtc.data[6]|((vga.crtc.data[7]&1));
 
400
 
 
401
        return lines;
 
402
}
 
403
 
 
404
static int vga_get_crtc_columns(void) /* in clocks! */
 
405
{
 
406
        int columns=vga.crtc.data[0]+5;
 
407
 
 
408
        if (!GRAPHIC_MODE)
 
409
                columns *= CHAR_WIDTH;
 
410
        else if (vga.gc.data[5]&0x40)
 
411
                columns *= 4;
 
412
        else
 
413
                columns *= 8;
 
414
 
 
415
        return columns;
 
416
}
 
417
 
 
418
static int vga_get_crtc_lines(void)
 
419
{
 
420
        int lines=(vga.crtc.data[6]
 
421
                           |((vga.crtc.data[7]&1)<<8)
 
422
                           |((vga.crtc.data[7]&0x20)<<(8-4)))+2;
 
423
 
 
424
        return lines;
 
425
}
 
426
 
 
427
static int vga_get_crtc_sync_lines(void)
 
428
{
 
429
        return 10;
 
430
}
 
431
 
 
432
static int vga_get_crtc_sync_columns(void)
 
433
{
 
434
        return 40;
 
435
}
 
436
 
 
437
INLINE WRITE8_HANDLER(vga_dirty_w)
 
438
{
 
439
        vga.memory[offset] = data;
 
440
}
 
441
 
 
442
INLINE WRITE8_HANDLER(vga_dirty_font_w)
 
443
{
 
444
        if (vga.memory[offset] != data)
 
445
        {
 
446
                vga.memory[offset] = data;
 
447
                if ((offset&3)==2)
 
448
                        vga.fontdirty[offset>>7]=1;
 
449
        }
 
450
}
 
451
 
 
452
static READ8_HANDLER(vga_text_r)
 
453
{
 
454
        int data;
 
455
        data=vga.memory[((offset&~1)<<1)|(offset&1)];
 
456
 
 
457
        return data;
 
458
}
 
459
 
 
460
static WRITE8_HANDLER(vga_text_w)
 
461
{
 
462
        vga_dirty_w(space, ((offset&~1)<<1)|(offset&1),data);
 
463
}
 
464
 
 
465
INLINE UINT8 ega_bitplane_to_packed(UINT8 *latch, int number)
 
466
{
 
467
        return color_bitplane_to_packed[0][number][latch[0]]
 
468
                |color_bitplane_to_packed[1][number][latch[1]]
 
469
                |color_bitplane_to_packed[2][number][latch[2]]
 
470
                |color_bitplane_to_packed[3][number][latch[3]];
 
471
}
 
472
 
 
473
static READ8_HANDLER(vga_ega_r)
 
474
{
 
475
        int data;
 
476
        vga.gc.latch[0]=vga.memory[(offset<<2)];
 
477
        vga.gc.latch[1]=vga.memory[(offset<<2)+1];
 
478
        vga.gc.latch[2]=vga.memory[(offset<<2)+2];
 
479
        vga.gc.latch[3]=vga.memory[(offset<<2)+3];
 
480
        if (vga.gc.data[5]&8) {
 
481
                data=0;
 
482
                if (!(ega_bitplane_to_packed(vga.gc.latch, 0)^(vga.gc.data[2]&0xf&~vga.gc.data[7]))) data|=1;
 
483
                if (!(ega_bitplane_to_packed(vga.gc.latch, 1)^(vga.gc.data[2]&0xf&~vga.gc.data[7]))) data|=2;
 
484
                if (!(ega_bitplane_to_packed(vga.gc.latch, 2)^(vga.gc.data[2]&0xf&~vga.gc.data[7]))) data|=4;
 
485
                if (!(ega_bitplane_to_packed(vga.gc.latch, 3)^(vga.gc.data[2]&0xf&~vga.gc.data[7]))) data|=8;
 
486
                if (!(ega_bitplane_to_packed(vga.gc.latch, 4)^(vga.gc.data[2]&0xf&~vga.gc.data[7]))) data|=0x10;
 
487
                if (!(ega_bitplane_to_packed(vga.gc.latch, 5)^(vga.gc.data[2]&0xf&~vga.gc.data[7]))) data|=0x20;
 
488
                if (!(ega_bitplane_to_packed(vga.gc.latch, 6)^(vga.gc.data[2]&0xf&~vga.gc.data[7]))) data|=0x40;
 
489
                if (!(ega_bitplane_to_packed(vga.gc.latch, 7)^(vga.gc.data[2]&0xf&~vga.gc.data[7]))) data|=0x80;
 
490
        } else {
 
491
                data=vga.gc.latch[vga.gc.data[4]&3];
 
492
        }
 
493
 
 
494
        return data;
 
495
}
 
496
 
 
497
INLINE UINT8 vga_latch_helper(UINT8 cpu, UINT8 latch, UINT8 mask)
 
498
{
 
499
        switch (vga.gc.data[3] & 0x18)
 
500
        {
 
501
                case 0x00:
 
502
                        return rotate_right((cpu&mask)|(latch&~mask), vga.gc.data[3] & 0x07);
 
503
                case 0x08:
 
504
                        return rotate_right(((cpu&latch)&mask)|(latch&~mask), vga.gc.data[3] & 0x07);
 
505
                case 0x10:
 
506
                        return rotate_right(((cpu|latch)&mask)|(latch&~mask), vga.gc.data[3] & 0x07);
 
507
                case 0x18:
 
508
                        return rotate_right(((cpu^latch)&mask)|(latch&~mask), vga.gc.data[3] & 0x07);
 
509
        }
 
510
        return 0; /* must not be reached, suppress compiler warning */
 
511
}
 
512
 
 
513
INLINE UINT8 vga_latch_write(int offs, UINT8 data)
 
514
{
 
515
        switch (vga.gc.data[5]&3) {
 
516
        case 0:
 
517
                if (vga.gc.data[1]&(1<<offs)) {
 
518
                        return vga_latch_helper( (vga.gc.data[0]&(1<<offs))?vga.gc.data[8]:0,
 
519
                                                                          vga.gc.latch[offs],vga.gc.data[8] );
 
520
                } else {
 
521
                        return vga_latch_helper(data, vga.gc.latch[offs], vga.gc.data[8]);
 
522
                }
 
523
                break;
 
524
        case 1:
 
525
                return vga.gc.latch[offs];
 
526
        case 2:
 
527
                if (data&(1<<offs)) {
 
528
                        return vga_latch_helper(0xff, vga.gc.latch[offs], vga.gc.data[8]);
 
529
                } else {
 
530
                        return vga_latch_helper(0, vga.gc.latch[offs], vga.gc.data[8]);
 
531
                }
 
532
                break;
 
533
        case 3:
 
534
                if (vga.gc.data[0]&(1<<offs)) {
 
535
                        return vga_latch_helper(0xff, vga.gc.latch[offs], data&vga.gc.data[8]);
 
536
                } else {
 
537
                        return vga_latch_helper(0, vga.gc.latch[offs], data&vga.gc.data[8]);
 
538
                }
 
539
                break;
 
540
        }
 
541
        return 0; /* must not be reached, suppress compiler warning */
 
542
}
 
543
 
 
544
static WRITE8_HANDLER(vga_ega_w)
 
545
{
 
546
        if (vga.sequencer.data[2]&1)
 
547
                vga_dirty_w(space, offset<<2, vga_latch_write(0,data));
 
548
        if (vga.sequencer.data[2]&2)
 
549
                vga_dirty_w(space, (offset<<2)+1, vga_latch_write(1,data));
 
550
        if (vga.sequencer.data[2]&4)
 
551
                vga_dirty_font_w(space, (offset<<2)+2, vga_latch_write(2,data));
 
552
        if (vga.sequencer.data[2]&8)
 
553
                vga_dirty_w(space, (offset<<2)+3, vga_latch_write(3,data));
 
554
        if ((offset==0xffff)&&(data==0)) vga.log=1;
 
555
}
 
556
 
 
557
static  READ8_HANDLER(vga_vga_r)
 
558
{
 
559
        int data;
 
560
        data=vga.memory[((offset&~3)<<2)|(offset&3)];
 
561
 
 
562
        return data;
 
563
}
 
564
 
 
565
static WRITE8_HANDLER(vga_vga_w)
 
566
{
 
567
        vga_dirty_font_w(space, ((offset&~3)<<2)|(offset&3),data);
 
568
}
 
569
 
 
570
/* 16 bit */
 
571
static READ16_HANDLER( vga_text16_r ) { return read16le_with_read8_handler(vga_text_r, space, offset, mem_mask); }
 
572
static READ16_HANDLER( vga_vga16_r ) { return read16le_with_read8_handler(vga_vga_r, space, offset, mem_mask); }
 
573
static WRITE16_HANDLER( vga_text16_w ) { write16le_with_write8_handler(vga_text_w, space, offset, data, mem_mask); }
 
574
static WRITE16_HANDLER( vga_vga16_w ) { write16le_with_write8_handler(vga_vga_w, space, offset, data, mem_mask); }
 
575
 
 
576
static READ16_HANDLER( vga_ega16_r ) { return read16le_with_read8_handler(vga_ega_r, space, offset, mem_mask); }
 
577
static WRITE16_HANDLER( vga_ega16_w ) { write16le_with_write8_handler(vga_ega_w, space, offset, data, mem_mask); }
 
578
 
 
579
/* 32 bit */
 
580
static READ32_HANDLER( vga_text32_r ) { return read32le_with_read8_handler(vga_text_r, space, offset, mem_mask); }
 
581
static READ32_HANDLER( vga_vga32_r ) { return read32le_with_read8_handler(vga_vga_r, space, offset, mem_mask); }
 
582
static WRITE32_HANDLER( vga_text32_w ) { write32le_with_write8_handler(vga_text_w, space, offset, data, mem_mask); }
 
583
static WRITE32_HANDLER( vga_vga32_w ) { write32le_with_write8_handler(vga_vga_w, space, offset, data, mem_mask); }
 
584
 
 
585
static READ32_HANDLER( vga_ega32_r ) { return read32le_with_read8_handler(vga_ega_r, space, offset, mem_mask); }
 
586
static WRITE32_HANDLER( vga_ega32_w ) { write32le_with_write8_handler(vga_ega_w, space, offset, data, mem_mask); }
 
587
 
 
588
/* 64 bit */
 
589
static READ64_HANDLER( vga_text64_r ) { return read64be_with_read8_handler(vga_text_r, space, offset, mem_mask); }
 
590
static READ64_HANDLER( vga_vga64_r ) { return read64be_with_read8_handler(vga_vga_r, space, offset, mem_mask); }
 
591
static WRITE64_HANDLER( vga_text64_w ) { write64be_with_write8_handler(vga_text_w, space, offset, data, mem_mask); }
 
592
static WRITE64_HANDLER( vga_vga64_w ) { write64be_with_write8_handler(vga_vga_w, space, offset, data, mem_mask); }
 
593
 
 
594
static READ64_HANDLER( vga_ega64_r ) { return read64be_with_read8_handler(vga_ega_r, space, offset, mem_mask); }
 
595
static WRITE64_HANDLER( vga_ega64_w ) { write64be_with_write8_handler(vga_ega_w, space, offset, data, mem_mask); }
 
596
 
 
597
static void vga_cpu_interface(running_machine *machine)
 
598
{
 
599
        const address_space *space = cpu_get_address_space(machine->firstcpu, ADDRESS_SPACE_PROGRAM);
 
600
        static int sequencer, gc;
 
601
        read8_space_func read_handler;
 
602
        write8_space_func write_handler;
 
603
        read16_space_func read_handler16;
 
604
        write16_space_func write_handler16;
 
605
        read32_space_func read_handler32;
 
606
        write32_space_func write_handler32;
 
607
        read64_space_func read_handler64;
 
608
        write64_space_func write_handler64;
 
609
        UINT8 sel;
 
610
        int buswidth;
 
611
 
 
612
        if ((gc==vga.gc.data[6])&&(sequencer==vga.sequencer.data[4])) return;
 
613
 
 
614
        gc=vga.gc.data[6];
 
615
        sequencer=vga.sequencer.data[4];
 
616
 
 
617
        if (vga.sequencer.data[4]&8)
 
618
        {
 
619
                read_handler = vga_vga_r;
 
620
                write_handler = vga_vga_w;
 
621
                read_handler16 = vga_vga16_r;
 
622
                write_handler16 = vga_vga16_w;
 
623
                read_handler32 = vga_vga32_r;
 
624
                write_handler32 = vga_vga32_w;
 
625
                read_handler64 = vga_vga64_r;
 
626
                write_handler64 = vga_vga64_w;
 
627
        }
 
628
        else if (vga.sequencer.data[4] & 4)
 
629
        {
 
630
                read_handler = vga_ega_r;
 
631
                write_handler = vga_ega_w;
 
632
                read_handler16 = vga_ega16_r;
 
633
                write_handler16 = vga_ega16_w;
 
634
                read_handler32 = vga_ega32_r;
 
635
                write_handler32 = vga_ega32_w;
 
636
                read_handler64 = vga_ega64_r;
 
637
                write_handler64 = vga_ega64_w;
 
638
        }
 
639
        else
 
640
        {
 
641
                read_handler = vga_text_r;
 
642
                write_handler = vga_text_w;
 
643
                read_handler16 = vga_text16_r;
 
644
                write_handler16 = vga_text16_w;
 
645
                read_handler32 = vga_text32_r;
 
646
                write_handler32 = vga_text32_w;
 
647
                read_handler64 = vga_text64_r;
 
648
                write_handler64 = vga_text64_w;
 
649
        }
 
650
 
 
651
        /* remap the VGA memory */
 
652
 
 
653
        if (vga.vga_intf.map_vga_memory)
 
654
        {
 
655
                sel = vga.gc.data[6] & 0x0c;
 
656
                switch(sel)
 
657
                {
 
658
                        case 0x00:
 
659
                                if (vga.vga_intf.vga_memory_bank != NULL)
 
660
                                {
 
661
                                        vga.vga_intf.map_vga_memory(machine, 0xA0000, 0xBFFFF, read_handler, write_handler);
 
662
                                        memory_set_bankptr(machine, vga.vga_intf.vga_memory_bank, vga.memory);
 
663
                                }
 
664
                                break;
 
665
                        case 0x04:
 
666
                                vga.vga_intf.map_vga_memory(machine, 0xA0000, 0xAFFFF, read_handler, write_handler);
 
667
                                break;
 
668
                        case 0x08:
 
669
                                vga.vga_intf.map_vga_memory(machine, 0xB0000, 0xB7FFF, read_handler, write_handler);
 
670
                                break;
 
671
                        case 0x0C:
 
672
                                vga.vga_intf.map_vga_memory(machine, 0xB8000, 0xBFFFF, read_handler, write_handler);
 
673
                                break;
 
674
                }
 
675
        }
 
676
        else
 
677
        {
 
678
                buswidth = downcast<cpu_device *>(machine->firstcpu)->space_config(AS_PROGRAM)->m_databus_width;
 
679
                switch(buswidth)
 
680
                {
 
681
                        case 8:
 
682
                                sel = vga.gc.data[6] & 0x0c;
 
683
                                if (sel)
 
684
                                {
 
685
                                        if (sel == 0x04) memory_install_read8_handler(space,  0xa0000, 0xaffff, 0, 0, read_handler ); else memory_nop_read(space,  0xa0000, 0xaffff, 0, 0);
 
686
                                        if (sel == 0x08) memory_install_read8_handler(space,  0xb0000, 0xb7fff, 0, 0, read_handler ); else memory_nop_read(space,  0xb0000, 0xb7fff, 0, 0);
 
687
                                        if (sel == 0x0C) memory_install_read8_handler(space,  0xb8000, 0xbffff, 0, 0, read_handler ); else memory_nop_read(space,  0xb8000, 0xbffff, 0, 0);
 
688
                                        if (sel == 0x04) memory_install_write8_handler(space, 0xa0000, 0xaffff, 0, 0, write_handler); else memory_nop_write(space, 0xa0000, 0xaffff, 0, 0);
 
689
                                        if (sel == 0x08) memory_install_write8_handler(space, 0xb0000, 0xb7fff, 0, 0, write_handler); else memory_nop_write(space, 0xb0000, 0xb7fff, 0, 0);
 
690
                                        if (sel == 0x0C) memory_install_write8_handler(space, 0xb8000, 0xbffff, 0, 0, write_handler); else memory_nop_write(space, 0xb8000, 0xbffff, 0, 0);
 
691
                                }
 
692
                                else
 
693
                                {
 
694
                                        memory_install_read_bank(space,  0xa0000, 0xbffff, 0, 0, "vgabank" );
 
695
                                        memory_install_write_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
 
696
                                        memory_set_bankptr(machine,"vgabank", vga.memory);
 
697
                                }
 
698
                                break;
 
699
 
 
700
                        case 16:
 
701
                                sel = vga.gc.data[6] & 0x0c;
 
702
                                if (sel)
 
703
                                {
 
704
                                        if (sel == 0x04) memory_install_read16_handler(space,  0xa0000, 0xaffff, 0, 0, read_handler16 ); else memory_nop_read(space,  0xa0000, 0xaffff, 0, 0);
 
705
                                        if (sel == 0x08) memory_install_read16_handler(space,  0xb0000, 0xb7fff, 0, 0, read_handler16 ); else memory_nop_read(space,  0xb0000, 0xb7fff, 0, 0);
 
706
                                        if (sel == 0x0C) memory_install_read16_handler(space,  0xb8000, 0xbffff, 0, 0, read_handler16 ); else memory_nop_read(space,  0xb8000, 0xbffff, 0, 0);
 
707
                                        if (sel == 0x04) memory_install_write16_handler(space, 0xa0000, 0xaffff, 0, 0, write_handler16); else memory_nop_write(space, 0xa0000, 0xaffff, 0, 0);
 
708
                                        if (sel == 0x08) memory_install_write16_handler(space, 0xb0000, 0xb7fff, 0, 0, write_handler16); else memory_nop_write(space, 0xb0000, 0xb7fff, 0, 0);
 
709
                                        if (sel == 0x0C) memory_install_write16_handler(space, 0xb8000, 0xbffff, 0, 0, write_handler16); else memory_nop_write(space, 0xb8000, 0xbffff, 0, 0);
 
710
                                }
 
711
                                else
 
712
                                {
 
713
                                        memory_install_read_bank(space,  0xa0000, 0xbffff, 0, 0, "vgabank" );
 
714
                                        memory_install_write_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
 
715
                                        memory_set_bankptr(machine,"vgabank", vga.memory);
 
716
                                }
 
717
                                break;
 
718
 
 
719
                        case 32:
 
720
                                sel = vga.gc.data[6] & 0x0c;
 
721
                                if (sel)
 
722
                                {
 
723
                                        if (sel == 0x04) memory_install_read32_handler(space,  0xa0000, 0xaffff, 0, 0, read_handler32 ); else memory_nop_read(space,  0xa0000, 0xaffff, 0, 0);
 
724
                                        if (sel == 0x08) memory_install_read32_handler(space,  0xb0000, 0xb7fff, 0, 0, read_handler32 ); else memory_nop_read(space,  0xb0000, 0xb7fff, 0, 0);
 
725
                                        if (sel == 0x0C) memory_install_read32_handler(space,  0xb8000, 0xbffff, 0, 0, read_handler32 ); else memory_nop_read(space,  0xb8000, 0xbffff, 0, 0);
 
726
                                        if (sel == 0x04) memory_install_write32_handler(space, 0xa0000, 0xaffff, 0, 0, write_handler32); else memory_nop_write(space, 0xa0000, 0xaffff, 0, 0);
 
727
                                        if (sel == 0x08) memory_install_write32_handler(space, 0xb0000, 0xb7fff, 0, 0, write_handler32); else memory_nop_write(space, 0xb0000, 0xb7fff, 0, 0);
 
728
                                        if (sel == 0x0C) memory_install_write32_handler(space, 0xb8000, 0xbffff, 0, 0, write_handler32); else memory_nop_write(space, 0xb8000, 0xbffff, 0, 0);
 
729
                                }
 
730
                                else
 
731
                                {
 
732
                                        memory_install_read_bank(space,  0xa0000, 0xbffff, 0, 0, "vgabank" );
 
733
                                        memory_install_write_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
 
734
                                        memory_set_bankptr(machine,"vgabank", vga.memory);
 
735
                                }
 
736
                                break;
 
737
 
 
738
                        case 64:
 
739
                                sel = vga.gc.data[6] & 0x0c;
 
740
                                if (sel)
 
741
                                {
 
742
                                        if (sel == 0x04) memory_install_read64_handler(space,  0xa0000, 0xaffff, 0, 0, read_handler64 ); else memory_nop_read(space,  0xa0000, 0xaffff, 0, 0);
 
743
                                        if (sel == 0x08) memory_install_read64_handler(space,  0xb0000, 0xb7fff, 0, 0, read_handler64 ); else memory_nop_read(space,  0xb0000, 0xb7fff, 0, 0);
 
744
                                        if (sel == 0x0C) memory_install_read64_handler(space,  0xb8000, 0xbffff, 0, 0, read_handler64 ); else memory_nop_read(space,  0xb8000, 0xbffff, 0, 0);
 
745
                                        if (sel == 0x04) memory_install_write64_handler(space, 0xa0000, 0xaffff, 0, 0, write_handler64); else memory_nop_write(space, 0xa0000, 0xaffff, 0, 0);
 
746
                                        if (sel == 0x08) memory_install_write64_handler(space, 0xb0000, 0xb7fff, 0, 0, write_handler64); else memory_nop_write(space, 0xb0000, 0xb7fff, 0, 0);
 
747
                                        if (sel == 0x0C) memory_install_write64_handler(space, 0xb8000, 0xbffff, 0, 0, write_handler64); else memory_nop_write(space, 0xb8000, 0xbffff, 0, 0);
 
748
                                }
 
749
                                else
 
750
                                {
 
751
                                        memory_install_read_bank(space,  0xa0000, 0xbffff, 0, 0, "vgabank" );
 
752
                                        memory_install_write_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
 
753
                                        memory_set_bankptr(machine,"vgabank", vga.memory);
 
754
                                }
 
755
                                break;
 
756
 
 
757
                        default:
 
758
                                fatalerror("VGA:  Bus width %d not supported\n", buswidth);
 
759
                                break;
 
760
                }
 
761
        }
 
762
}
 
763
 
 
764
static READ8_HANDLER(vga_crtc_r)
 
765
{
 
766
        UINT8 data = 0xff;
 
767
 
 
768
        switch (offset) {
 
769
        case 4:
 
770
                data = vga.crtc.index;
 
771
                break;
 
772
        case 5:
 
773
                if (vga.crtc.index < vga.svga_intf.crtc_regcount)
 
774
                        data = vga.crtc.data[vga.crtc.index];
 
775
                break;
 
776
        case 0xa:
 
777
                vga.attribute.state = 0;
 
778
                data = 0;/*4; */
 
779
#if 0 /* slow */
 
780
                {
 
781
                        int clock=vga.monitor.get_clock();
 
782
                        int lines=vga.monitor.get_lines();
 
783
                        int columns=vga.monitor.get_columns();
 
784
                        int diff = (attotime_mul(attotime_sub(timer_get_time(space->machine), vga.monitor.start_time), clock).seconds)
 
785
                                %(lines*columns);
 
786
                        if (diff<columns*vga.monitor.get_sync_lines()) data|=8;
 
787
                        diff=diff/lines;
 
788
                        if (diff%columns<vga.monitor.get_sync_columns()) data|=1;
 
789
                }
 
790
#elif 1
 
791
                if (vga.monitor.retrace)
 
792
                {
 
793
                        data |= 1;
 
794
                        if (attotime_compare(attotime_sub(timer_get_time(space->machine), vga.monitor.start_time), ATTOTIME_IN_USEC(300)) > 0)
 
795
                        {
 
796
                                data |= 8;
 
797
                                vga.monitor.retrace=0;
 
798
                        }
 
799
                }
 
800
                else
 
801
                {
 
802
                        if (attotime_compare(attotime_sub(timer_get_time(space->machine), vga.monitor.start_time), ATTOTIME_IN_MSEC(15)) > 0)
 
803
                                vga.monitor.retrace=1;
 
804
                        vga.monitor.start_time=timer_get_time(space->machine);
 
805
                }
 
806
#else
 
807
                // not working with ps2m30
 
808
                if (vga.monitor.retrace) data|=9;
 
809
                vga.monitor.retrace=0;
 
810
#endif
 
811
                /* ega diagnostic readback enough for oak bios */
 
812
                switch (vga.attribute.data[0x12]&0x30) {
 
813
                case 0:
 
814
                        if (vga.attribute.data[0x11]&1) data|=0x10;
 
815
                        if (vga.attribute.data[0x11]&4) data|=0x20;
 
816
                        break;
 
817
                case 0x10:
 
818
                        data|=(vga.attribute.data[0x11]&0x30);
 
819
                        break;
 
820
                case 0x20:
 
821
                        if (vga.attribute.data[0x11]&2) data|=0x10;
 
822
                        if (vga.attribute.data[0x11]&8) data|=0x20;
 
823
                        break;
 
824
                case 0x30:
 
825
                        data|=(vga.attribute.data[0x11]&0xc0)>>2;
 
826
                        break;
 
827
                }
 
828
                break;
 
829
        case 0xf:
 
830
                /* oak test */
 
831
                data=0;
 
832
                /* pega bios on/off */
 
833
                data=0x80;
 
834
                break;
 
835
        }
 
836
        return data;
 
837
}
 
838
 
 
839
static WRITE8_HANDLER(vga_crtc_w)
 
840
{
 
841
        switch (offset)
 
842
        {
 
843
                case 0xa:
 
844
                        vga.feature_control = data;
 
845
                        break;
 
846
 
 
847
                case 4:
 
848
                        vga.crtc.index = data;
 
849
                        break;
 
850
 
 
851
                case 5:
 
852
                        if (LOG_REGISTERS)
 
853
                        {
 
854
                                logerror("vga_crtc_w(): CRTC[0x%02X %s] = 0x%02X\n",
 
855
                                        vga.crtc.index,
 
856
                                        (vga.crtc.index < vga.svga_intf.crtc_regcount) ? vga_crtc_reg_names[vga.crtc.index] : "?",
 
857
                                        data);
 
858
                        }
 
859
                        if(vga.crtc.index == 0x18 || vga.crtc.index == 0x07 || vga.crtc.index == 0x19 ) // Line compare
 
860
                                vga.line_compare = (((vga.crtc.data[0x09] & 0x40) << 3) | ((vga.crtc.data[0x07] & 0x10) << 4) | vga.crtc.data[0x18])/2;
 
861
                        if (vga.crtc.index < vga.svga_intf.crtc_regcount)
 
862
                                vga.crtc.data[vga.crtc.index] = data;
 
863
                        break;
 
864
        }
 
865
}
 
866
 
 
867
 
 
868
 
 
869
READ8_HANDLER( vga_port_03b0_r )
 
870
{
 
871
        UINT8 data = 0xff;
 
872
        if (CRTC_PORT_ADDR==0x3b0)
 
873
                data=vga_crtc_r(space, offset);
 
874
        return data;
 
875
}
 
876
 
 
877
 
 
878
 
 
879
READ8_HANDLER( ega_port_03c0_r)
 
880
{
 
881
        UINT8 data = 0xff;
 
882
        switch (offset) {
 
883
        case 2: data=0xff;/*!*/break;
 
884
        }
 
885
        return data;
 
886
}
 
887
 
 
888
READ8_HANDLER( vga_port_03c0_r )
 
889
{
 
890
        UINT8 data = 0xff;
 
891
 
 
892
        switch (offset)
 
893
        {
 
894
                case 1:
 
895
                        if (vga.attribute.state==0)
 
896
                        {
 
897
                                data = vga.attribute.index;
 
898
                        }
 
899
                        else
 
900
                        {
 
901
                                if ((vga.attribute.index&0x1f)<sizeof(vga.attribute.data))
 
902
                                        data=vga.attribute.data[vga.attribute.index&0x1f];
 
903
                        }
 
904
                        break;
 
905
 
 
906
                case 2:
 
907
                        data = 0;
 
908
                        switch ((vga.miscellaneous_output>>2)&3)
 
909
                        {
 
910
                                case 3:
 
911
                                        if (vga.vga_intf.read_dipswitch && vga.vga_intf.read_dipswitch(space, 0) & 0x01)
 
912
                                                data |= 0x10;
 
913
                                        break;
 
914
                                case 2:
 
915
                                        if (vga.vga_intf.read_dipswitch && vga.vga_intf.read_dipswitch(space, 0) & 0x02)
 
916
                                                data |= 0x10;
 
917
                                        break;
 
918
                                case 1:
 
919
                                        if (vga.vga_intf.read_dipswitch && vga.vga_intf.read_dipswitch(space, 0) & 0x04)
 
920
                                                data |= 0x10;
 
921
                                        break;
 
922
                                case 0:
 
923
                                        if (vga.vga_intf.read_dipswitch && vga.vga_intf.read_dipswitch(space, 0) & 0x08)
 
924
                                                data |= 0x10;
 
925
                                        break;
 
926
                        }
 
927
                        break;
 
928
 
 
929
                case 3:
 
930
                        data = vga.oak.reg;
 
931
                        break;
 
932
 
 
933
                case 4:
 
934
                        data = vga.sequencer.index;
 
935
                        break;
 
936
 
 
937
                case 5:
 
938
                        if (vga.sequencer.index < vga.svga_intf.seq_regcount)
 
939
                                data = vga.sequencer.data[vga.sequencer.index];
 
940
                        break;
 
941
 
 
942
                case 6:
 
943
                        data = vga.dac.mask;
 
944
                        break;
 
945
 
 
946
                case 7:
 
947
                        if (vga.dac.read)
 
948
                                data = 0;
 
949
                        else
 
950
                                data = 3;
 
951
                        break;
 
952
 
 
953
                case 8:
 
954
                        data = vga.dac.write_index;
 
955
                        break;
 
956
 
 
957
                case 9:
 
958
                        if (vga.dac.read)
 
959
                        {
 
960
                                switch (vga.dac.state++)
 
961
                                {
 
962
                                        case 0:
 
963
                                                data = vga.dac.color[vga.dac.read_index].red;
 
964
                                                break;
 
965
                                        case 1:
 
966
                                                data = vga.dac.color[vga.dac.read_index].green;
 
967
                                                break;
 
968
                                        case 2:
 
969
                                                data = vga.dac.color[vga.dac.read_index].blue;
 
970
                                                break;
 
971
                                }
 
972
 
 
973
                                if (vga.dac.state==3)
 
974
                                {
 
975
                                        vga.dac.state = 0;
 
976
                                        vga.dac.read_index++;
 
977
                                }
 
978
                        }
 
979
                        break;
 
980
 
 
981
                case 0xa:
 
982
                        data = vga.feature_control;
 
983
                        break;
 
984
 
 
985
                case 0xc:
 
986
                        data = vga.miscellaneous_output;
 
987
                        break;
 
988
 
 
989
                case 0xe:
 
990
                        data = vga.gc.index;
 
991
                        break;
 
992
 
 
993
                case 0xf:
 
994
                        if (vga.gc.index < vga.svga_intf.gc_regcount)
 
995
                                data = vga.gc.data[vga.gc.index];
 
996
                        break;
 
997
        }
 
998
        return data;
 
999
}
 
1000
 
 
1001
READ8_HANDLER(vga_port_03d0_r)
 
1002
{
 
1003
        UINT8 data = 0xff;
 
1004
        if (CRTC_PORT_ADDR == 0x3d0)
 
1005
                data = vga_crtc_r(space, offset);
 
1006
        return data;
 
1007
}
 
1008
 
 
1009
WRITE8_HANDLER( vga_port_03b0_w )
 
1010
{
 
1011
        if (LOG_ACCESSES)
 
1012
                logerror("vga_port_03b0_w(): port=0x%04x data=0x%02x\n", offset + 0x3b0, data);
 
1013
 
 
1014
        if (CRTC_PORT_ADDR == 0x3b0)
 
1015
                vga_crtc_w(space, offset, data);
 
1016
}
 
1017
 
 
1018
WRITE8_HANDLER(vga_port_03c0_w)
 
1019
{
 
1020
        if (LOG_ACCESSES)
 
1021
                logerror("vga_port_03c0_w(): port=0x%04x data=0x%02x\n", offset + 0x3c0, data);
 
1022
 
 
1023
        switch (offset) {
 
1024
        case 0:
 
1025
                if (vga.attribute.state==0)
 
1026
                {
 
1027
                        vga.attribute.index=data;
 
1028
                }
 
1029
                else
 
1030
                {
 
1031
                        if ((vga.attribute.index&0x1f)<sizeof(vga.attribute.data))
 
1032
                                vga.attribute.data[vga.attribute.index&0x1f]=data;
 
1033
                }
 
1034
                vga.attribute.state=!vga.attribute.state;
 
1035
                break;
 
1036
        case 2:
 
1037
                vga.miscellaneous_output=data;
 
1038
                break;
 
1039
        case 3:
 
1040
                vga.oak.reg = data;
 
1041
                break;
 
1042
        case 4:
 
1043
                vga.sequencer.index = data;
 
1044
                break;
 
1045
        case 5:
 
1046
                if (LOG_REGISTERS)
 
1047
                {
 
1048
                        logerror("vga_port_03c0_w(): SEQ[0x%02X%s] = 0x%02X\n",
 
1049
                                vga.sequencer.index,
 
1050
                                (vga.sequencer.index < vga.svga_intf.seq_regcount) ? "" : "?",
 
1051
                                data);
 
1052
                }
 
1053
                if (vga.sequencer.index < vga.svga_intf.seq_regcount)
 
1054
                {
 
1055
                        vga.sequencer.data[vga.sequencer.index] = data;
 
1056
                        vga_cpu_interface(space->machine);
 
1057
 
 
1058
                        if (vga.sequencer.index == 0)
 
1059
                                vga.monitor.start_time = timer_get_time(space->machine);
 
1060
                }
 
1061
                break;
 
1062
        case 6:
 
1063
                vga.dac.mask=data;
 
1064
                break;
 
1065
        case 7:
 
1066
                vga.dac.read_index=data;
 
1067
                vga.dac.state=0;
 
1068
                vga.dac.read=1;
 
1069
                break;
 
1070
        case 8:
 
1071
                vga.dac.write_index=data;
 
1072
                vga.dac.state=0;
 
1073
                vga.dac.read=0;
 
1074
                break;
 
1075
        case 9:
 
1076
                if (!vga.dac.read)
 
1077
                {
 
1078
                        switch (vga.dac.state++) {
 
1079
                        case 0:
 
1080
                                vga.dac.color[vga.dac.write_index].red=data;
 
1081
                                break;
 
1082
                        case 1:
 
1083
                                vga.dac.color[vga.dac.write_index].green=data;
 
1084
                                break;
 
1085
                        case 2:
 
1086
                                vga.dac.color[vga.dac.write_index].blue=data;
 
1087
                                break;
 
1088
                        }
 
1089
                        vga.dac.dirty=1;
 
1090
                        if (vga.dac.state==3) {
 
1091
                                vga.dac.state=0; vga.dac.write_index++;
 
1092
#if 0
 
1093
                                if (vga.dac.write_index==64) {
 
1094
                                        int i;
 
1095
                                        mame_printf_debug("start palette\n");
 
1096
                                        for (i=0;i<64;i++) {
 
1097
                                                mame_printf_debug(" 0x%.2x, 0x%.2x, 0x%.2x,\n",
 
1098
                                                           vga.dac.color[i].red*4,
 
1099
                                                           vga.dac.color[i].green*4,
 
1100
                                                           vga.dac.color[i].blue*4);
 
1101
                                        }
 
1102
                                }
 
1103
#endif
 
1104
                        }
 
1105
                }
 
1106
                break;
 
1107
        case 0xe:
 
1108
                vga.gc.index=data;
 
1109
                break;
 
1110
        case 0xf:
 
1111
                if (LOG_REGISTERS)
 
1112
                {
 
1113
                        logerror("vga_port_03c0_w(): GC[0x%02X%s] = 0x%02X\n",
 
1114
                                vga.gc.index,
 
1115
                                (vga.gc.index < vga.svga_intf.gc_regcount) ? "" : "?",
 
1116
                                data);
 
1117
                }
 
1118
                if (vga.gc.index < vga.svga_intf.gc_regcount)
 
1119
                {
 
1120
                        vga.gc.data[vga.gc.index] = data;
 
1121
                        vga_cpu_interface(space->machine);
 
1122
                }
 
1123
                break;
 
1124
        }
 
1125
}
 
1126
 
 
1127
 
 
1128
 
 
1129
WRITE8_HANDLER(vga_port_03d0_w)
 
1130
{
 
1131
        if (LOG_ACCESSES)
 
1132
                logerror("vga_port_03d0_w(): port=0x%04x data=0x%02x\n", offset + 0x3d0, data);
 
1133
 
 
1134
        if (CRTC_PORT_ADDR == 0x3d0)
 
1135
                vga_crtc_w(space, offset, data);
 
1136
}
 
1137
 
 
1138
 
 
1139
 
 
1140
READ8_HANDLER( paradise_ega_03c0_r )
 
1141
{
 
1142
        UINT8 data = vga_port_03c0_r(space, offset);
 
1143
 
 
1144
        if (offset == 2)
 
1145
        {
 
1146
                if ( (vga.feature_control&3)==2 ) {
 
1147
                        data=(data&~0x60)|((vga.vga_intf.read_dipswitch(space, 0)&0xc0)>>1);
 
1148
                } else if ((vga.feature_control&3)==1 ) {
 
1149
                        data=(data&~0x60)|((vga.vga_intf.read_dipswitch(space, 0)&0x30)<<1);
 
1150
                }
 
1151
        }
 
1152
        return data;
 
1153
}
 
1154
 
 
1155
 
 
1156
 
 
1157
void pc_vga_reset(running_machine *machine)
 
1158
{
 
1159
        /* clear out the VGA structure */
 
1160
        memset(vga.pens, 0, sizeof(vga.pens));
 
1161
        vga.miscellaneous_output = 1;
 
1162
        vga.feature_control = 0;
 
1163
        vga.sequencer.index = 0;
 
1164
        memset(vga.sequencer.data, 0, vga.svga_intf.seq_regcount * sizeof(*vga.sequencer.data));
 
1165
        vga.crtc.index = 0;
 
1166
        memset(vga.crtc.data, 0, vga.svga_intf.crtc_regcount * sizeof(*vga.crtc.data));
 
1167
        vga.gc.index = 0;
 
1168
        memset(vga.gc.data, 0, vga.svga_intf.gc_regcount * sizeof(*vga.gc.data));
 
1169
        memset(vga.gc.latch, 0, sizeof(vga.gc.latch));
 
1170
        memset(&vga.attribute, 0, sizeof(vga.attribute));
 
1171
        memset(&vga.dac, 0, sizeof(vga.dac));
 
1172
        memset(&vga.cursor, 0, sizeof(vga.cursor));
 
1173
        memset(&vga.monitor, 0, sizeof(vga.monitor));
 
1174
        memset(&vga.oak, 0, sizeof(vga.oak));
 
1175
        vga.log = 0;
 
1176
 
 
1177
        vga.gc.data[6] = 0xc; /* prevent xtbios excepting vga ram as system ram */
 
1178
/* amstrad pc1640 bios relies on the position of
 
1179
   the video memory area,
 
1180
   so I introduced the reset to switch to b8000 area */
 
1181
        vga.sequencer.data[4] = 0;
 
1182
        vga_cpu_interface(machine);
 
1183
 
 
1184
        vga.line_compare = 0x3ff;
 
1185
        // set CRTC register to match the line compare value
 
1186
        vga.crtc.data[0x18] = vga.line_compare & 0xff;
 
1187
        if(vga.line_compare & 0x100)
 
1188
                vga.crtc.data[0x07] |= 0x10;
 
1189
        if(vga.line_compare & 0x200)
 
1190
                vga.crtc.data[0x09] |= 0x40;
 
1191
}
 
1192
 
 
1193
/* 16 bit */
 
1194
READ16_HANDLER( vga_port16le_03b0_r ) { return read16le_with_read8_handler(vga_port_03b0_r, space, offset, mem_mask); }
 
1195
READ16_HANDLER( vga_port16le_03c0_r ) { return read16le_with_read8_handler(vga_port_03c0_r, space, offset, mem_mask); }
 
1196
READ16_HANDLER( vga_port16le_03d0_r ) { return read16le_with_read8_handler(vga_port_03d0_r, space, offset, mem_mask); }
 
1197
 
 
1198
WRITE16_HANDLER( vga_port16le_03b0_w ) { write16le_with_write8_handler(vga_port_03b0_w, space, offset, data, mem_mask); }
 
1199
WRITE16_HANDLER( vga_port16le_03c0_w ) { write16le_with_write8_handler(vga_port_03c0_w, space, offset, data, mem_mask); }
 
1200
WRITE16_HANDLER( vga_port16le_03d0_w ) { write16le_with_write8_handler(vga_port_03d0_w, space, offset, data, mem_mask); }
 
1201
 
 
1202
/* 32 bit */
 
1203
static READ32_HANDLER( vga_port32le_03b0_r ) { return read32le_with_read8_handler(vga_port_03b0_r, space, offset, mem_mask); }
 
1204
static READ32_HANDLER( vga_port32le_03c0_r ) { return read32le_with_read8_handler(vga_port_03c0_r, space, offset, mem_mask); }
 
1205
static READ32_HANDLER( vga_port32le_03d0_r ) { return read32le_with_read8_handler(vga_port_03d0_r, space, offset, mem_mask); }
 
1206
 
 
1207
static WRITE32_HANDLER( vga_port32le_03b0_w ) { write32le_with_write8_handler(vga_port_03b0_w, space, offset, data, mem_mask); }
 
1208
static WRITE32_HANDLER( vga_port32le_03c0_w ) { write32le_with_write8_handler(vga_port_03c0_w, space, offset, data, mem_mask); }
 
1209
static WRITE32_HANDLER( vga_port32le_03d0_w ) { write32le_with_write8_handler(vga_port_03d0_w, space, offset, data, mem_mask); }
 
1210
 
 
1211
/* 64 bit */
 
1212
static READ64_HANDLER( vga_port64be_03b0_r ) { return read64be_with_read8_handler(vga_port_03b0_r, space, offset, mem_mask); }
 
1213
static READ64_HANDLER( vga_port64be_03c0_r ) { return read64be_with_read8_handler(vga_port_03c0_r, space, offset, mem_mask); }
 
1214
static READ64_HANDLER( vga_port64be_03d0_r ) { return read64be_with_read8_handler(vga_port_03d0_r, space, offset, mem_mask); }
 
1215
 
 
1216
static WRITE64_HANDLER( vga_port64be_03b0_w ) { write64be_with_write8_handler(vga_port_03b0_w, space, offset, data, mem_mask); }
 
1217
static WRITE64_HANDLER( vga_port64be_03c0_w ) { write64be_with_write8_handler(vga_port_03c0_w, space, offset, data, mem_mask); }
 
1218
static WRITE64_HANDLER( vga_port64be_03d0_w ) { write64be_with_write8_handler(vga_port_03d0_w, space, offset, data, mem_mask); }
 
1219
 
 
1220
void pc_vga_init(running_machine *machine, const struct pc_vga_interface *vga_intf, const struct pc_svga_interface *svga_intf)
 
1221
{
 
1222
        int i, j, k, mask, buswidth;
 
1223
        const address_space *spacevga;
 
1224
 
 
1225
        memset(&vga, 0, sizeof(vga));
 
1226
 
 
1227
        for (k=0;k<4;k++)
 
1228
        {
 
1229
                for (mask=0x80, j=0; j<8; j++, mask>>=1)
 
1230
                {
 
1231
                        for  (i=0; i<256; i++)
 
1232
                                color_bitplane_to_packed[k][j][i]=(i&mask)?(1<<k):0;
 
1233
                }
 
1234
        }
 
1235
 
 
1236
        /* copy over interfaces */
 
1237
        vga.vga_intf = *vga_intf;
 
1238
        if (svga_intf)
 
1239
        {
 
1240
                vga.svga_intf = *svga_intf;
 
1241
 
 
1242
                if (vga.svga_intf.seq_regcount < 0x05)
 
1243
                        fatalerror("Invalid SVGA sequencer register count");
 
1244
                if (vga.svga_intf.gc_regcount < 0x09)
 
1245
                        fatalerror("Invalid SVGA GC register count");
 
1246
                if (vga.svga_intf.crtc_regcount < 0x19)
 
1247
                        fatalerror("Invalid SVGA CRTC register count");
 
1248
        }
 
1249
        else
 
1250
        {
 
1251
                vga.svga_intf.vram_size = 0x40000;
 
1252
                vga.svga_intf.seq_regcount = 0x05;
 
1253
                vga.svga_intf.gc_regcount = 0x09;
 
1254
                vga.svga_intf.crtc_regcount = 0x19;
 
1255
        }
 
1256
 
 
1257
        vga.memory                      = auto_alloc_array(machine, UINT8, vga.svga_intf.vram_size);
 
1258
        vga.fontdirty           = auto_alloc_array(machine, UINT8, 0x800);
 
1259
        vga.sequencer.data      = auto_alloc_array(machine, UINT8, vga.svga_intf.seq_regcount);
 
1260
        vga.crtc.data           = auto_alloc_array(machine, UINT8, vga.svga_intf.crtc_regcount);
 
1261
        vga.gc.data                     = auto_alloc_array(machine, UINT8, vga.svga_intf.gc_regcount);
 
1262
        memset(vga.memory, '\0', vga.svga_intf.vram_size);
 
1263
        memset(vga.fontdirty, '\0', 0x800);
 
1264
        memset(vga.sequencer.data, '\0', vga.svga_intf.seq_regcount);
 
1265
        memset(vga.crtc.data, '\0', vga.svga_intf.crtc_regcount);
 
1266
        memset(vga.gc.data, '\0', vga.svga_intf.gc_regcount);
 
1267
 
 
1268
        buswidth = downcast<cpu_device *>(machine->firstcpu)->space_config(AS_PROGRAM)->m_databus_width;
 
1269
        spacevga = cpu_get_address_space(machine->firstcpu,vga.vga_intf.port_addressspace);
 
1270
        switch(buswidth)
 
1271
        {
 
1272
                case 8:
 
1273
                        memory_install_read8_handler(spacevga, vga.vga_intf.port_offset + 0x3b0, vga.vga_intf.port_offset + 0x3bf, 0, 0, vga_port_03b0_r );
 
1274
                        memory_install_read8_handler(spacevga, vga.vga_intf.port_offset + 0x3c0, vga.vga_intf.port_offset + 0x3cf, 0, 0, vga_port_03c0_r );
 
1275
                        memory_install_read8_handler(spacevga, vga.vga_intf.port_offset + 0x3d0, vga.vga_intf.port_offset + 0x3df, 0, 0, vga_port_03d0_r );
 
1276
 
 
1277
                        memory_install_write8_handler(spacevga, vga.vga_intf.port_offset + 0x3b0, vga.vga_intf.port_offset + 0x3bf, 0, 0, vga_port_03b0_w );
 
1278
                        memory_install_write8_handler(spacevga, vga.vga_intf.port_offset + 0x3c0, vga.vga_intf.port_offset + 0x3cf, 0, 0, vga_port_03c0_w );
 
1279
                        memory_install_write8_handler(spacevga, vga.vga_intf.port_offset + 0x3d0, vga.vga_intf.port_offset + 0x3df, 0, 0, vga_port_03d0_w );
 
1280
                        break;
 
1281
 
 
1282
                case 16:
 
1283
                        memory_install_read16_handler(spacevga, vga.vga_intf.port_offset + 0x3b0, vga.vga_intf.port_offset + 0x3bf, 0, 0, vga_port16le_03b0_r );
 
1284
                        memory_install_read16_handler(spacevga, vga.vga_intf.port_offset + 0x3c0, vga.vga_intf.port_offset + 0x3cf, 0, 0, vga_port16le_03c0_r );
 
1285
                        memory_install_read16_handler(spacevga, vga.vga_intf.port_offset + 0x3d0, vga.vga_intf.port_offset + 0x3df, 0, 0, vga_port16le_03d0_r );
 
1286
 
 
1287
                        memory_install_write16_handler(spacevga, vga.vga_intf.port_offset + 0x3b0, vga.vga_intf.port_offset + 0x3bf, 0, 0, vga_port16le_03b0_w );
 
1288
                        memory_install_write16_handler(spacevga, vga.vga_intf.port_offset + 0x3c0, vga.vga_intf.port_offset + 0x3cf, 0, 0, vga_port16le_03c0_w );
 
1289
                        memory_install_write16_handler(spacevga, vga.vga_intf.port_offset + 0x3d0, vga.vga_intf.port_offset + 0x3df, 0, 0, vga_port16le_03d0_w );
 
1290
                        break;
 
1291
 
 
1292
                case 32:
 
1293
                        memory_install_read32_handler(spacevga, vga.vga_intf.port_offset + 0x3b0, vga.vga_intf.port_offset + 0x3bf, 0, 0, vga_port32le_03b0_r );
 
1294
                        memory_install_read32_handler(spacevga, vga.vga_intf.port_offset + 0x3c0, vga.vga_intf.port_offset + 0x3cf, 0, 0, vga_port32le_03c0_r );
 
1295
                        memory_install_read32_handler(spacevga, vga.vga_intf.port_offset + 0x3d0, vga.vga_intf.port_offset + 0x3df, 0, 0, vga_port32le_03d0_r );
 
1296
 
 
1297
                        memory_install_write32_handler(spacevga, vga.vga_intf.port_offset + 0x3b0, vga.vga_intf.port_offset + 0x3bf, 0, 0, vga_port32le_03b0_w );
 
1298
                        memory_install_write32_handler(spacevga, vga.vga_intf.port_offset + 0x3c0, vga.vga_intf.port_offset + 0x3cf, 0, 0, vga_port32le_03c0_w );
 
1299
                        memory_install_write32_handler(spacevga, vga.vga_intf.port_offset + 0x3d0, vga.vga_intf.port_offset + 0x3df, 0, 0, vga_port32le_03d0_w );
 
1300
                        break;
 
1301
 
 
1302
                case 64:
 
1303
                        memory_install_read64_handler(spacevga, vga.vga_intf.port_offset + 0x3b0, vga.vga_intf.port_offset + 0x3bf, 0, 0, vga_port64be_03b0_r );
 
1304
                        memory_install_read64_handler(spacevga, vga.vga_intf.port_offset + 0x3c0, vga.vga_intf.port_offset + 0x3cf, 0, 0, vga_port64be_03c0_r );
 
1305
                        memory_install_read64_handler(spacevga, vga.vga_intf.port_offset + 0x3d0, vga.vga_intf.port_offset + 0x3df, 0, 0, vga_port64be_03d0_r );
 
1306
 
 
1307
                        memory_install_write64_handler(spacevga, vga.vga_intf.port_offset + 0x3b0, vga.vga_intf.port_offset + 0x3bf, 0, 0, vga_port64be_03b0_w );
 
1308
                        memory_install_write64_handler(spacevga, vga.vga_intf.port_offset + 0x3c0, vga.vga_intf.port_offset + 0x3cf, 0, 0, vga_port64be_03c0_w );
 
1309
                        memory_install_write64_handler(spacevga, vga.vga_intf.port_offset + 0x3d0, vga.vga_intf.port_offset + 0x3df, 0, 0, vga_port64be_03d0_w );
 
1310
                        break;
 
1311
        }
 
1312
 
 
1313
        pc_vga_reset(machine);
 
1314
}
 
1315
 
 
1316
static TIMER_CALLBACK(vga_timer)
 
1317
{
 
1318
        vga.monitor.retrace=1;
 
1319
}
 
1320
 
 
1321
static VIDEO_START( ega )
 
1322
{
 
1323
        vga.monitor.get_clock = ega_get_clock;
 
1324
        vga.monitor.get_lines = ega_get_crtc_lines;
 
1325
        vga.monitor.get_columns = ega_get_crtc_columns;
 
1326
        vga.monitor.get_sync_lines = vga_get_crtc_sync_lines;
 
1327
        vga.monitor.get_sync_columns = vga_get_crtc_sync_columns;
 
1328
        timer_pulse(machine, ATTOTIME_IN_HZ(60), NULL, 0, vga_timer);
 
1329
        pc_video_start(machine, pc_ega_choosevideomode, 0);
 
1330
}
 
1331
 
 
1332
static VIDEO_RESET( ega )
 
1333
{
 
1334
}
 
1335
 
 
1336
static VIDEO_START( vga )
 
1337
{
 
1338
        vga.monitor.get_clock=vga_get_clock;
 
1339
        vga.monitor.get_lines=vga_get_crtc_lines;
 
1340
        vga.monitor.get_columns=vga_get_crtc_columns;
 
1341
        vga.monitor.get_sync_lines=vga_get_crtc_sync_lines;
 
1342
        vga.monitor.get_sync_columns=vga_get_crtc_sync_columns;
 
1343
        timer_pulse(machine, ATTOTIME_IN_HZ(60), NULL, 0, vga_timer);
 
1344
        pc_video_start(machine, pc_vga_choosevideomode, 0);
 
1345
}
 
1346
 
 
1347
static VIDEO_RESET( vga )
 
1348
{
 
1349
        pc_vga_reset(machine);
 
1350
}
 
1351
 
 
1352
static void vga_vh_text(bitmap_t *bitmap)
 
1353
{
 
1354
        UINT8 ch, attr;
 
1355
        UINT8 bits;
 
1356
        UINT8 *font;
 
1357
        UINT16 *bitmapline;
 
1358
        int width=CHAR_WIDTH, height=CRTC6845_CHAR_HEIGHT;
 
1359
        int pos, line, column, mask, w, h, addr;
 
1360
        pen_t pen;
 
1361
 
 
1362
        if (CRTC6845_CURSOR_MODE!=CRTC6845_CURSOR_OFF)
 
1363
        {
 
1364
                if (++vga.cursor.time>=0x10)
 
1365
                {
 
1366
                        vga.cursor.visible^=1;
 
1367
                        vga.cursor.time=0;
 
1368
                }
 
1369
        }
 
1370
 
 
1371
        for (addr = TEXT_START_ADDRESS, line = -CRTC6845_SKEW; line < TEXT_LINES;
 
1372
                 line += height, addr += TEXT_LINE_LENGTH)
 
1373
        {
 
1374
                for (pos = addr, column=0; column<TEXT_COLUMNS; column++, pos++)
 
1375
                {
 
1376
                        ch   = vga.memory[(pos<<2) + 0];
 
1377
                        attr = vga.memory[(pos<<2) + 1];
 
1378
                        font = vga.memory+2+(ch<<(5+2))+FONT1;
 
1379
 
 
1380
                        for (h = MAX(-line, 0); (h < height) && (line+h < MIN(TEXT_LINES, bitmap->height)); h++)
 
1381
                        {
 
1382
                                bitmapline = BITMAP_ADDR16(bitmap, line+h, 0);
 
1383
                                bits = font[h<<2];
 
1384
 
 
1385
                                assert(bitmapline);
 
1386
 
 
1387
                                for (mask=0x80, w=0; (w<width)&&(w<8); w++, mask>>=1)
 
1388
                                {
 
1389
                                        if (bits&mask)
 
1390
                                                pen = vga.pens[attr & 0x0f];
 
1391
                                        else
 
1392
                                                pen = vga.pens[attr >> 4];
 
1393
                                        bitmapline[column*width+w] = pen;
 
1394
                                }
 
1395
                                if (w<width)
 
1396
                                {
 
1397
                                        /* 9 column */
 
1398
                                        if (TEXT_COPY_9COLUMN(ch)&&(bits&1))
 
1399
                                                pen = vga.pens[attr & 0x0f];
 
1400
                                        else
 
1401
                                                pen = vga.pens[attr >> 4];
 
1402
                                        bitmapline[column*width+w] = pen;
 
1403
                                }
 
1404
                        }
 
1405
                        if ((CRTC6845_CURSOR_MODE!=CRTC6845_CURSOR_OFF)
 
1406
                                &&vga.cursor.visible&&(pos==CRTC6845_CURSOR_POS))
 
1407
                        {
 
1408
                                for (h=CRTC6845_CURSOR_TOP;
 
1409
                                         (h<=CRTC6845_CURSOR_BOTTOM)&&(h<height)&&(line+h<TEXT_LINES);
 
1410
                                         h++)
 
1411
                                {
 
1412
                                        plot_box(bitmap, column*width, line+h, width, 1, vga.pens[attr&0xf]);
 
1413
                                }
 
1414
                        }
 
1415
                }
 
1416
        }
 
1417
}
 
1418
 
 
1419
static void vga_vh_ega(bitmap_t *bitmap)
 
1420
{
 
1421
        int pos, line, column, c, addr, i;
 
1422
        int height = CRTC6845_CHAR_HEIGHT;
 
1423
        UINT16 *bitmapline;
 
1424
        UINT16 *newbitmapline;
 
1425
        pen_t pen;
 
1426
 
 
1427
        for (addr=EGA_START_ADDRESS, pos=0, line=0; line<LINES;
 
1428
                 line += height, addr=(addr+EGA_LINE_LENGTH)&0x3ffff)
 
1429
        {
 
1430
                bitmapline = BITMAP_ADDR16(bitmap, line, 0);
 
1431
 
 
1432
                for (pos=addr, c=0, column=0; column<EGA_COLUMNS; column++, c+=8, pos=(pos+4)&0x3ffff)
 
1433
                {
 
1434
                        int data[4];
 
1435
 
 
1436
                        data[0]=vga.memory[pos];
 
1437
                        data[1]=vga.memory[pos+1]<<1;
 
1438
                        data[2]=vga.memory[pos+2]<<2;
 
1439
                        data[3]=vga.memory[pos+3]<<3;
 
1440
 
 
1441
                        for (i = 7; i >= 0; i--)
 
1442
                        {
 
1443
                                pen = vga.pens[(data[0]&1) | (data[1]&2) | (data[2]&4) | (data[3]&8)];
 
1444
                                bitmapline[c+i] = pen;
 
1445
 
 
1446
                                data[0]>>=1;
 
1447
                                data[1]>>=1;
 
1448
                                data[2]>>=1;
 
1449
                                data[3]>>=1;
 
1450
                        }
 
1451
                }
 
1452
 
 
1453
                for (i = 1; i < height; i++)
 
1454
                {
 
1455
                        if (line + i >= LINES)
 
1456
                                break;
 
1457
 
 
1458
                        newbitmapline = BITMAP_ADDR16(bitmap, line+i, 0);
 
1459
                        memcpy(newbitmapline, bitmapline, EGA_COLUMNS * 8 * sizeof(UINT16));
 
1460
                }
 
1461
        }
 
1462
}
 
1463
 
 
1464
static void vga_vh_vga(bitmap_t *bitmap)
 
1465
{
 
1466
        int pos, line, column, c, addr, curr_addr;
 
1467
        UINT16 *bitmapline;
 
1468
 
 
1469
        curr_addr = 0;
 
1470
        if(vga.sequencer.data[4] & 0x08)
 
1471
        {
 
1472
                for (addr = VGA_START_ADDRESS, line=0; line<LINES; line++, addr+=VGA_LINE_LENGTH, curr_addr+=VGA_LINE_LENGTH)
 
1473
                {
 
1474
                        if(line < (vga.line_compare & 0xff))
 
1475
                                curr_addr = addr;
 
1476
                        if(line == (vga.line_compare & 0xff))
 
1477
                                curr_addr = 0;
 
1478
                        bitmapline = BITMAP_ADDR16(bitmap, line, 0);
 
1479
                        addr %= vga.svga_intf.vram_size;
 
1480
                        for (pos=curr_addr, c=0, column=0; column<VGA_COLUMNS; column++, c+=8, pos+=0x20)
 
1481
                        {
 
1482
                                if(pos + 0x20 > vga.svga_intf.vram_size)
 
1483
                                        return;
 
1484
                                bitmapline[c+0] = vga.memory[pos+0];
 
1485
                                bitmapline[c+1] = vga.memory[pos+1];
 
1486
                                bitmapline[c+2] = vga.memory[pos+2];
 
1487
                                bitmapline[c+3] = vga.memory[pos+3];
 
1488
                                bitmapline[c+4] = vga.memory[pos+0x10];
 
1489
                                bitmapline[c+5] = vga.memory[pos+0x11];
 
1490
                                bitmapline[c+6] = vga.memory[pos+0x12];
 
1491
                                bitmapline[c+7] = vga.memory[pos+0x13];
 
1492
                        }
 
1493
                }
 
1494
        }
 
1495
        else
 
1496
        {
 
1497
                for (addr = VGA_START_ADDRESS, line=0; line<LINES; line++, addr+=VGA_LINE_LENGTH/4, curr_addr+=VGA_LINE_LENGTH/4)
 
1498
                {
 
1499
                        if(line < (vga.line_compare & 0xff))
 
1500
                                curr_addr = addr;
 
1501
                        if(line == (vga.line_compare & 0xff))
 
1502
                                curr_addr = 0;
 
1503
                        bitmapline = BITMAP_ADDR16(bitmap, line, 0);
 
1504
                        addr %= vga.svga_intf.vram_size;
 
1505
                        for (pos=curr_addr, c=0, column=0; column<VGA_COLUMNS; column++, c+=8, pos+=0x08)
 
1506
                        {
 
1507
                                if(pos + 0x08 > vga.svga_intf.vram_size)
 
1508
                                        return;
 
1509
                                bitmapline[c+0] = vga.memory[pos+0];
 
1510
                                bitmapline[c+1] = vga.memory[pos+1];
 
1511
                                bitmapline[c+2] = vga.memory[pos+2];
 
1512
                                bitmapline[c+3] = vga.memory[pos+3];
 
1513
                                bitmapline[c+4] = vga.memory[pos+4];
 
1514
                                bitmapline[c+5] = vga.memory[pos+5];
 
1515
                                bitmapline[c+6] = vga.memory[pos+6];
 
1516
                                bitmapline[c+7] = vga.memory[pos+7];
 
1517
                        }
 
1518
                }
 
1519
        }
 
1520
}
 
1521
 
 
1522
static pc_video_update_proc pc_ega_choosevideomode(running_machine *machine, int *width, int *height)
 
1523
{
 
1524
        pc_video_update_proc proc = NULL;
 
1525
        int i;
 
1526
 
 
1527
        //if (CRTC_ON)
 
1528
        {
 
1529
                for (i = 0; i < 16; i++)
 
1530
                        vga.pens[i]=machine->pens[i/*vga.attribute.data[i]&0x3f*/];
 
1531
 
 
1532
                if (!GRAPHIC_MODE)
 
1533
                {
 
1534
                        proc = vga_vh_text;
 
1535
                        *height = TEXT_LINES;
 
1536
                        *width = TEXT_COLUMNS*CHAR_WIDTH;
 
1537
                }
 
1538
                else
 
1539
                {
 
1540
                        proc = vga_vh_ega;
 
1541
                        *height = LINES;
 
1542
                        *width = EGA_COLUMNS*8;
 
1543
                }
 
1544
        }
 
1545
        return proc;
 
1546
}
 
1547
 
 
1548
static pc_video_update_proc pc_vga_choosevideomode(running_machine *machine, int *width, int *height)
 
1549
{
 
1550
        pc_video_update_proc proc = NULL;
 
1551
        int i;
 
1552
 
 
1553
        //if (CRTC_ON)
 
1554
        {
 
1555
                if (vga.dac.dirty)
 
1556
                {
 
1557
                        for (i=0; i<256;i++)
 
1558
                        {
 
1559
                                palette_set_color_rgb(machine, i,(vga.dac.color[i].red & 0x3f) << 2,
 
1560
                                                                         (vga.dac.color[i].green & 0x3f) << 2,
 
1561
                                                                         (vga.dac.color[i].blue & 0x3f) << 2);
 
1562
                        }
 
1563
                        vga.dac.dirty = 0;
 
1564
                }
 
1565
 
 
1566
                if (vga.attribute.data[0x10] & 0x80)
 
1567
                {
 
1568
                        for (i=0; i<16;i++)
 
1569
                        {
 
1570
                                vga.pens[i] = machine->pens[(vga.attribute.data[i]&0x0f)
 
1571
                                                                                 |((vga.attribute.data[0x14]&0xf)<<4)];
 
1572
                        }
 
1573
                }
 
1574
                else
 
1575
                {
 
1576
                        for (i=0; i<16;i++)
 
1577
                        {
 
1578
                                vga.pens[i]=machine->pens[(vga.attribute.data[i]&0x3f)
 
1579
                                                                                 |((vga.attribute.data[0x14]&0xc)<<4)];
 
1580
                        }
 
1581
                }
 
1582
 
 
1583
                if (vga.svga_intf.choosevideomode)
 
1584
                        proc = vga.svga_intf.choosevideomode(vga.sequencer.data, vga.crtc.data, vga.gc.data, width, height);
 
1585
 
 
1586
                if (!proc)
 
1587
                {
 
1588
                        if (!GRAPHIC_MODE)
 
1589
                        {
 
1590
                                proc = vga_vh_text;
 
1591
                                *height = TEXT_LINES;
 
1592
                                *width = TEXT_COLUMNS * CHAR_WIDTH;
 
1593
                        }
 
1594
                        else if (vga.gc.data[5]&0x40)
 
1595
                        {
 
1596
                                proc = vga_vh_vga;
 
1597
                                *height = LINES;
 
1598
                                *width = VGA_COLUMNS * 8;
 
1599
                        }
 
1600
                        else
 
1601
                        {
 
1602
                                proc = vga_vh_ega;
 
1603
                                *height = LINES;
 
1604
                                *width = EGA_COLUMNS * 8;
 
1605
                        }
 
1606
                }
 
1607
        }
 
1608
        return proc;
 
1609
}
 
1610
 
 
1611
 
 
1612
 
 
1613
void *pc_vga_memory(void)
 
1614
{
 
1615
        return vga.memory;
 
1616
}
 
1617
 
 
1618
 
 
1619
 
 
1620
size_t pc_vga_memory_size(void)
 
1621
{
 
1622
        return vga.svga_intf.vram_size;
 
1623
}
 
1624
 
 
1625
READ16_HANDLER( paradise_ega16le_03c0_r ) { return read16le_with_read8_handler(paradise_ega_03c0_r, space, offset, mem_mask); }