← Back to branch summary

~ahs3/+junk/cq-qemu

« back to all changes in this revision

Viewing changes to hw/cirrus_vga.c

  • Committer: Al Stone
  • Date: 2012-02-09 01:17:20 UTC
  • Revision ID: albert.stone@canonical.com-20120209011720-tztl7ik3qayz80p4
first commit to bzr for qemu

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/cirrus_vga.c
 
1
/*
 
2
 * QEMU Cirrus CLGD 54xx VGA Emulator.
 
3
 *
 
4
 * Copyright (c) 2004 Fabrice Bellard
 
5
 * Copyright (c) 2004 Makoto Suzuki (suzu)
 
6
 *
 
7
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 
8
 * of this software and associated documentation files (the "Software"), to deal
 
9
 * in the Software without restriction, including without limitation the rights
 
10
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
11
 * copies of the Software, and to permit persons to whom the Software is
 
12
 * furnished to do so, subject to the following conditions:
 
13
 *
 
14
 * The above copyright notice and this permission notice shall be included in
 
15
 * all copies or substantial portions of the Software.
 
16
 *
 
17
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
18
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
19
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 
20
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
21
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
22
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
23
 * THE SOFTWARE.
 
24
 */
 
25
/*
 
26
 * Reference: Finn Thogersons' VGADOC4b
 
27
 *   available at http://home.worldonline.dk/~finth/
 
28
 */
 
29
#include "hw.h"
 
30
#include "pc.h"
 
31
#include "pci.h"
 
32
#include "console.h"
 
33
#include "vga_int.h"
 
34
#include "loader.h"
 
35
 
 
36
/*
 
37
 * TODO:
 
38
 *    - destination write mask support not complete (bits 5..7)
 
39
 *    - optimize linear mappings
 
40
 *    - optimize bitblt functions
 
41
 */
 
42
 
 
43
//#define DEBUG_CIRRUS
 
44
//#define DEBUG_BITBLT
 
45
 
 
46
/***************************************
 
47
 *
 
48
 *  definitions
 
49
 *
 
50
 ***************************************/
 
51
 
 
52
// ID
 
53
#define CIRRUS_ID_CLGD5422  (0x23<<2)
 
54
#define CIRRUS_ID_CLGD5426  (0x24<<2)
 
55
#define CIRRUS_ID_CLGD5424  (0x25<<2)
 
56
#define CIRRUS_ID_CLGD5428  (0x26<<2)
 
57
#define CIRRUS_ID_CLGD5430  (0x28<<2)
 
58
#define CIRRUS_ID_CLGD5434  (0x2A<<2)
 
59
#define CIRRUS_ID_CLGD5436  (0x2B<<2)
 
60
#define CIRRUS_ID_CLGD5446  (0x2E<<2)
 
61
 
 
62
// sequencer 0x07
 
63
#define CIRRUS_SR7_BPP_VGA            0x00
 
64
#define CIRRUS_SR7_BPP_SVGA           0x01
 
65
#define CIRRUS_SR7_BPP_MASK           0x0e
 
66
#define CIRRUS_SR7_BPP_8              0x00
 
67
#define CIRRUS_SR7_BPP_16_DOUBLEVCLK  0x02
 
68
#define CIRRUS_SR7_BPP_24             0x04
 
69
#define CIRRUS_SR7_BPP_16             0x06
 
70
#define CIRRUS_SR7_BPP_32             0x08
 
71
#define CIRRUS_SR7_ISAADDR_MASK       0xe0
 
72
 
 
73
// sequencer 0x0f
 
74
#define CIRRUS_MEMSIZE_512k        0x08
 
75
#define CIRRUS_MEMSIZE_1M          0x10
 
76
#define CIRRUS_MEMSIZE_2M          0x18
 
77
#define CIRRUS_MEMFLAGS_BANKSWITCH 0x80 // bank switching is enabled.
 
78
 
 
79
// sequencer 0x12
 
80
#define CIRRUS_CURSOR_SHOW         0x01
 
81
#define CIRRUS_CURSOR_HIDDENPEL    0x02
 
82
#define CIRRUS_CURSOR_LARGE        0x04 // 64x64 if set, 32x32 if clear
 
83
 
 
84
// sequencer 0x17
 
85
#define CIRRUS_BUSTYPE_VLBFAST   0x10
 
86
#define CIRRUS_BUSTYPE_PCI       0x20
 
87
#define CIRRUS_BUSTYPE_VLBSLOW   0x30
 
88
#define CIRRUS_BUSTYPE_ISA       0x38
 
89
#define CIRRUS_MMIO_ENABLE       0x04
 
90
#define CIRRUS_MMIO_USE_PCIADDR  0x40   // 0xb8000 if cleared.
 
91
#define CIRRUS_MEMSIZEEXT_DOUBLE 0x80
 
92
 
 
93
// control 0x0b
 
94
#define CIRRUS_BANKING_DUAL             0x01
 
95
#define CIRRUS_BANKING_GRANULARITY_16K  0x20    // set:16k, clear:4k
 
96
 
 
97
// control 0x30
 
98
#define CIRRUS_BLTMODE_BACKWARDS        0x01
 
99
#define CIRRUS_BLTMODE_MEMSYSDEST       0x02
 
100
#define CIRRUS_BLTMODE_MEMSYSSRC        0x04
 
101
#define CIRRUS_BLTMODE_TRANSPARENTCOMP  0x08
 
102
#define CIRRUS_BLTMODE_PATTERNCOPY      0x40
 
103
#define CIRRUS_BLTMODE_COLOREXPAND      0x80
 
104
#define CIRRUS_BLTMODE_PIXELWIDTHMASK   0x30
 
105
#define CIRRUS_BLTMODE_PIXELWIDTH8      0x00
 
106
#define CIRRUS_BLTMODE_PIXELWIDTH16     0x10
 
107
#define CIRRUS_BLTMODE_PIXELWIDTH24     0x20
 
108
#define CIRRUS_BLTMODE_PIXELWIDTH32     0x30
 
109
 
 
110
// control 0x31
 
111
#define CIRRUS_BLT_BUSY                 0x01
 
112
#define CIRRUS_BLT_START                0x02
 
113
#define CIRRUS_BLT_RESET                0x04
 
114
#define CIRRUS_BLT_FIFOUSED             0x10
 
115
#define CIRRUS_BLT_AUTOSTART            0x80
 
116
 
 
117
// control 0x32
 
118
#define CIRRUS_ROP_0                    0x00
 
119
#define CIRRUS_ROP_SRC_AND_DST          0x05
 
120
#define CIRRUS_ROP_NOP                  0x06
 
121
#define CIRRUS_ROP_SRC_AND_NOTDST       0x09
 
122
#define CIRRUS_ROP_NOTDST               0x0b
 
123
#define CIRRUS_ROP_SRC                  0x0d
 
124
#define CIRRUS_ROP_1                    0x0e
 
125
#define CIRRUS_ROP_NOTSRC_AND_DST       0x50
 
126
#define CIRRUS_ROP_SRC_XOR_DST          0x59
 
127
#define CIRRUS_ROP_SRC_OR_DST           0x6d
 
128
#define CIRRUS_ROP_NOTSRC_OR_NOTDST     0x90
 
129
#define CIRRUS_ROP_SRC_NOTXOR_DST       0x95
 
130
#define CIRRUS_ROP_SRC_OR_NOTDST        0xad
 
131
#define CIRRUS_ROP_NOTSRC               0xd0
 
132
#define CIRRUS_ROP_NOTSRC_OR_DST        0xd6
 
133
#define CIRRUS_ROP_NOTSRC_AND_NOTDST    0xda
 
134
 
 
135
#define CIRRUS_ROP_NOP_INDEX 2
 
136
#define CIRRUS_ROP_SRC_INDEX 5
 
137
 
 
138
// control 0x33
 
139
#define CIRRUS_BLTMODEEXT_SOLIDFILL        0x04
 
140
#define CIRRUS_BLTMODEEXT_COLOREXPINV      0x02
 
141
#define CIRRUS_BLTMODEEXT_DWORDGRANULARITY 0x01
 
142
 
 
143
// memory-mapped IO
 
144
#define CIRRUS_MMIO_BLTBGCOLOR        0x00      // dword
 
145
#define CIRRUS_MMIO_BLTFGCOLOR        0x04      // dword
 
146
#define CIRRUS_MMIO_BLTWIDTH          0x08      // word
 
147
#define CIRRUS_MMIO_BLTHEIGHT         0x0a      // word
 
148
#define CIRRUS_MMIO_BLTDESTPITCH      0x0c      // word
 
149
#define CIRRUS_MMIO_BLTSRCPITCH       0x0e      // word
 
150
#define CIRRUS_MMIO_BLTDESTADDR       0x10      // dword
 
151
#define CIRRUS_MMIO_BLTSRCADDR        0x14      // dword
 
152
#define CIRRUS_MMIO_BLTWRITEMASK      0x17      // byte
 
153
#define CIRRUS_MMIO_BLTMODE           0x18      // byte
 
154
#define CIRRUS_MMIO_BLTROP            0x1a      // byte
 
155
#define CIRRUS_MMIO_BLTMODEEXT        0x1b      // byte
 
156
#define CIRRUS_MMIO_BLTTRANSPARENTCOLOR 0x1c    // word?
 
157
#define CIRRUS_MMIO_BLTTRANSPARENTCOLORMASK 0x20        // word?
 
158
#define CIRRUS_MMIO_LINEARDRAW_START_X 0x24     // word
 
159
#define CIRRUS_MMIO_LINEARDRAW_START_Y 0x26     // word
 
160
#define CIRRUS_MMIO_LINEARDRAW_END_X  0x28      // word
 
161
#define CIRRUS_MMIO_LINEARDRAW_END_Y  0x2a      // word
 
162
#define CIRRUS_MMIO_LINEARDRAW_LINESTYLE_INC 0x2c       // byte
 
163
#define CIRRUS_MMIO_LINEARDRAW_LINESTYLE_ROLLOVER 0x2d  // byte
 
164
#define CIRRUS_MMIO_LINEARDRAW_LINESTYLE_MASK 0x2e      // byte
 
165
#define CIRRUS_MMIO_LINEARDRAW_LINESTYLE_ACCUM 0x2f     // byte
 
166
#define CIRRUS_MMIO_BRESENHAM_K1      0x30      // word
 
167
#define CIRRUS_MMIO_BRESENHAM_K3      0x32      // word
 
168
#define CIRRUS_MMIO_BRESENHAM_ERROR   0x34      // word
 
169
#define CIRRUS_MMIO_BRESENHAM_DELTA_MAJOR 0x36  // word
 
170
#define CIRRUS_MMIO_BRESENHAM_DIRECTION 0x38    // byte
 
171
#define CIRRUS_MMIO_LINEDRAW_MODE     0x39      // byte
 
172
#define CIRRUS_MMIO_BLTSTATUS         0x40      // byte
 
173
 
 
174
#define CIRRUS_PNPMMIO_SIZE         0x1000
 
175
 
 
176
#define BLTUNSAFE(s) \
 
177
    ( \
 
178
        ( /* check dst is within bounds */ \
 
179
            (s)->cirrus_blt_height * ABS((s)->cirrus_blt_dstpitch) \
 
180
                + ((s)->cirrus_blt_dstaddr & (s)->cirrus_addr_mask) > \
 
181
                    (s)->vga.vram_size \
 
182
        ) || \
 
183
        ( /* check src is within bounds */ \
 
184
            (s)->cirrus_blt_height * ABS((s)->cirrus_blt_srcpitch) \
 
185
                + ((s)->cirrus_blt_srcaddr & (s)->cirrus_addr_mask) > \
 
186
                    (s)->vga.vram_size \
 
187
        ) \
 
188
    )
 
189
 
 
190
struct CirrusVGAState;
 
191
typedef void (*cirrus_bitblt_rop_t) (struct CirrusVGAState *s,
 
192
                                     uint8_t * dst, const uint8_t * src,
 
193
                                     int dstpitch, int srcpitch,
 
194
                                     int bltwidth, int bltheight);
 
195
typedef void (*cirrus_fill_t)(struct CirrusVGAState *s,
 
196
                              uint8_t *dst, int dst_pitch, int width, int height);
 
197
 
 
198
typedef struct CirrusVGAState {
 
199
    VGACommonState vga;
 
200
 
 
201
    MemoryRegion cirrus_linear_io;
 
202
    MemoryRegion cirrus_linear_bitblt_io;
 
203
    MemoryRegion cirrus_mmio_io;
 
204
    MemoryRegion pci_bar;
 
205
    bool linear_vram;  /* vga.vram mapped over cirrus_linear_io */
 
206
    MemoryRegion low_mem_container; /* container for 0xa0000-0xc0000 */
 
207
    MemoryRegion low_mem;           /* always mapped, overridden by: */
 
208
    MemoryRegion *cirrus_bank[2];   /*   aliases at 0xa0000-0xb0000  */
 
209
    uint32_t cirrus_addr_mask;
 
210
    uint32_t linear_mmio_mask;
 
211
    uint8_t cirrus_shadow_gr0;
 
212
    uint8_t cirrus_shadow_gr1;
 
213
    uint8_t cirrus_hidden_dac_lockindex;
 
214
    uint8_t cirrus_hidden_dac_data;
 
215
    uint32_t cirrus_bank_base[2];
 
216
    uint32_t cirrus_bank_limit[2];
 
217
    uint8_t cirrus_hidden_palette[48];
 
218
    uint32_t hw_cursor_x;
 
219
    uint32_t hw_cursor_y;
 
220
    int cirrus_blt_pixelwidth;
 
221
    int cirrus_blt_width;
 
222
    int cirrus_blt_height;
 
223
    int cirrus_blt_dstpitch;
 
224
    int cirrus_blt_srcpitch;
 
225
    uint32_t cirrus_blt_fgcol;
 
226
    uint32_t cirrus_blt_bgcol;
 
227
    uint32_t cirrus_blt_dstaddr;
 
228
    uint32_t cirrus_blt_srcaddr;
 
229
    uint8_t cirrus_blt_mode;
 
230
    uint8_t cirrus_blt_modeext;
 
231
    cirrus_bitblt_rop_t cirrus_rop;
 
232
#define CIRRUS_BLTBUFSIZE (2048 * 4) /* one line width */
 
233
    uint8_t cirrus_bltbuf[CIRRUS_BLTBUFSIZE];
 
234
    uint8_t *cirrus_srcptr;
 
235
    uint8_t *cirrus_srcptr_end;
 
236
    uint32_t cirrus_srccounter;
 
237
    /* hwcursor display state */
 
238
    int last_hw_cursor_size;
 
239
    int last_hw_cursor_x;
 
240
    int last_hw_cursor_y;
 
241
    int last_hw_cursor_y_start;
 
242
    int last_hw_cursor_y_end;
 
243
    int real_vram_size; /* XXX: suppress that */
 
244
    int device_id;
 
245
    int bustype;
 
246
} CirrusVGAState;
 
247
 
 
248
typedef struct PCICirrusVGAState {
 
249
    PCIDevice dev;
 
250
    CirrusVGAState cirrus_vga;
 
251
} PCICirrusVGAState;
 
252
 
 
253
static uint8_t rop_to_index[256];
 
254
 
 
255
/***************************************
 
256
 *
 
257
 *  prototypes.
 
258
 *
 
259
 ***************************************/
 
260
 
 
261
 
 
262
static void cirrus_bitblt_reset(CirrusVGAState *s);
 
263
static void cirrus_update_memory_access(CirrusVGAState *s);
 
264
 
 
265
/***************************************
 
266
 *
 
267
 *  raster operations
 
268
 *
 
269
 ***************************************/
 
270
 
 
271
static void cirrus_bitblt_rop_nop(CirrusVGAState *s,
 
272
                                  uint8_t *dst,const uint8_t *src,
 
273
                                  int dstpitch,int srcpitch,
 
274
                                  int bltwidth,int bltheight)
 
275
{
 
276
}
 
277
 
 
278
static void cirrus_bitblt_fill_nop(CirrusVGAState *s,
 
279
                                   uint8_t *dst,
 
280
                                   int dstpitch, int bltwidth,int bltheight)
 
281
{
 
282
}
 
283
 
 
284
#define ROP_NAME 0
 
285
#define ROP_FN(d, s) 0
 
286
#include "cirrus_vga_rop.h"
 
287
 
 
288
#define ROP_NAME src_and_dst
 
289
#define ROP_FN(d, s) (s) & (d)
 
290
#include "cirrus_vga_rop.h"
 
291
 
 
292
#define ROP_NAME src_and_notdst
 
293
#define ROP_FN(d, s) (s) & (~(d))
 
294
#include "cirrus_vga_rop.h"
 
295
 
 
296
#define ROP_NAME notdst
 
297
#define ROP_FN(d, s) ~(d)
 
298
#include "cirrus_vga_rop.h"
 
299
 
 
300
#define ROP_NAME src
 
301
#define ROP_FN(d, s) s
 
302
#include "cirrus_vga_rop.h"
 
303
 
 
304
#define ROP_NAME 1
 
305
#define ROP_FN(d, s) ~0
 
306
#include "cirrus_vga_rop.h"
 
307
 
 
308
#define ROP_NAME notsrc_and_dst
 
309
#define ROP_FN(d, s) (~(s)) & (d)
 
310
#include "cirrus_vga_rop.h"
 
311
 
 
312
#define ROP_NAME src_xor_dst
 
313
#define ROP_FN(d, s) (s) ^ (d)
 
314
#include "cirrus_vga_rop.h"
 
315
 
 
316
#define ROP_NAME src_or_dst
 
317
#define ROP_FN(d, s) (s) | (d)
 
318
#include "cirrus_vga_rop.h"
 
319
 
 
320
#define ROP_NAME notsrc_or_notdst
 
321
#define ROP_FN(d, s) (~(s)) | (~(d))
 
322
#include "cirrus_vga_rop.h"
 
323
 
 
324
#define ROP_NAME src_notxor_dst
 
325
#define ROP_FN(d, s) ~((s) ^ (d))
 
326
#include "cirrus_vga_rop.h"
 
327
 
 
328
#define ROP_NAME src_or_notdst
 
329
#define ROP_FN(d, s) (s) | (~(d))
 
330
#include "cirrus_vga_rop.h"
 
331
 
 
332
#define ROP_NAME notsrc
 
333
#define ROP_FN(d, s) (~(s))
 
334
#include "cirrus_vga_rop.h"
 
335
 
 
336
#define ROP_NAME notsrc_or_dst
 
337
#define ROP_FN(d, s) (~(s)) | (d)
 
338
#include "cirrus_vga_rop.h"
 
339
 
 
340
#define ROP_NAME notsrc_and_notdst
 
341
#define ROP_FN(d, s) (~(s)) & (~(d))
 
342
#include "cirrus_vga_rop.h"
 
343
 
 
344
static const cirrus_bitblt_rop_t cirrus_fwd_rop[16] = {
 
345
    cirrus_bitblt_rop_fwd_0,
 
346
    cirrus_bitblt_rop_fwd_src_and_dst,
 
347
    cirrus_bitblt_rop_nop,
 
348
    cirrus_bitblt_rop_fwd_src_and_notdst,
 
349
    cirrus_bitblt_rop_fwd_notdst,
 
350
    cirrus_bitblt_rop_fwd_src,
 
351
    cirrus_bitblt_rop_fwd_1,
 
352
    cirrus_bitblt_rop_fwd_notsrc_and_dst,
 
353
    cirrus_bitblt_rop_fwd_src_xor_dst,
 
354
    cirrus_bitblt_rop_fwd_src_or_dst,
 
355
    cirrus_bitblt_rop_fwd_notsrc_or_notdst,
 
356
    cirrus_bitblt_rop_fwd_src_notxor_dst,
 
357
    cirrus_bitblt_rop_fwd_src_or_notdst,
 
358
    cirrus_bitblt_rop_fwd_notsrc,
 
359
    cirrus_bitblt_rop_fwd_notsrc_or_dst,
 
360
    cirrus_bitblt_rop_fwd_notsrc_and_notdst,
 
361
};
 
362
 
 
363
static const cirrus_bitblt_rop_t cirrus_bkwd_rop[16] = {
 
364
    cirrus_bitblt_rop_bkwd_0,
 
365
    cirrus_bitblt_rop_bkwd_src_and_dst,
 
366
    cirrus_bitblt_rop_nop,
 
367
    cirrus_bitblt_rop_bkwd_src_and_notdst,
 
368
    cirrus_bitblt_rop_bkwd_notdst,
 
369
    cirrus_bitblt_rop_bkwd_src,
 
370
    cirrus_bitblt_rop_bkwd_1,
 
371
    cirrus_bitblt_rop_bkwd_notsrc_and_dst,
 
372
    cirrus_bitblt_rop_bkwd_src_xor_dst,
 
373
    cirrus_bitblt_rop_bkwd_src_or_dst,
 
374
    cirrus_bitblt_rop_bkwd_notsrc_or_notdst,
 
375
    cirrus_bitblt_rop_bkwd_src_notxor_dst,
 
376
    cirrus_bitblt_rop_bkwd_src_or_notdst,
 
377
    cirrus_bitblt_rop_bkwd_notsrc,
 
378
    cirrus_bitblt_rop_bkwd_notsrc_or_dst,
 
379
    cirrus_bitblt_rop_bkwd_notsrc_and_notdst,
 
380
};
 
381
 
 
382
#define TRANSP_ROP(name) {\
 
383
    name ## _8,\
 
384
    name ## _16,\
 
385
        }
 
386
#define TRANSP_NOP(func) {\
 
387
    func,\
 
388
    func,\
 
389
        }
 
390
 
 
391
static const cirrus_bitblt_rop_t cirrus_fwd_transp_rop[16][2] = {
 
392
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_0),
 
393
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_src_and_dst),
 
394
    TRANSP_NOP(cirrus_bitblt_rop_nop),
 
395
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_src_and_notdst),
 
396
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_notdst),
 
397
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_src),
 
398
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_1),
 
399
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_notsrc_and_dst),
 
400
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_src_xor_dst),
 
401
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_src_or_dst),
 
402
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_notsrc_or_notdst),
 
403
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_src_notxor_dst),
 
404
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_src_or_notdst),
 
405
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_notsrc),
 
406
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_notsrc_or_dst),
 
407
    TRANSP_ROP(cirrus_bitblt_rop_fwd_transp_notsrc_and_notdst),
 
408
};
 
409
 
 
410
static const cirrus_bitblt_rop_t cirrus_bkwd_transp_rop[16][2] = {
 
411
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_0),
 
412
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_src_and_dst),
 
413
    TRANSP_NOP(cirrus_bitblt_rop_nop),
 
414
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_src_and_notdst),
 
415
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_notdst),
 
416
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_src),
 
417
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_1),
 
418
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_notsrc_and_dst),
 
419
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_src_xor_dst),
 
420
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_src_or_dst),
 
421
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_notsrc_or_notdst),
 
422
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_src_notxor_dst),
 
423
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_src_or_notdst),
 
424
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_notsrc),
 
425
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_notsrc_or_dst),
 
426
    TRANSP_ROP(cirrus_bitblt_rop_bkwd_transp_notsrc_and_notdst),
 
427
};
 
428
 
 
429
#define ROP2(name) {\
 
430
    name ## _8,\
 
431
    name ## _16,\
 
432
    name ## _24,\
 
433
    name ## _32,\
 
434
        }
 
435
 
 
436
#define ROP_NOP2(func) {\
 
437
    func,\
 
438
    func,\
 
439
    func,\
 
440
    func,\
 
441
        }
 
442
 
 
443
static const cirrus_bitblt_rop_t cirrus_patternfill[16][4] = {
 
444
    ROP2(cirrus_patternfill_0),
 
445
    ROP2(cirrus_patternfill_src_and_dst),
 
446
    ROP_NOP2(cirrus_bitblt_rop_nop),
 
447
    ROP2(cirrus_patternfill_src_and_notdst),
 
448
    ROP2(cirrus_patternfill_notdst),
 
449
    ROP2(cirrus_patternfill_src),
 
450
    ROP2(cirrus_patternfill_1),
 
451
    ROP2(cirrus_patternfill_notsrc_and_dst),
 
452
    ROP2(cirrus_patternfill_src_xor_dst),
 
453
    ROP2(cirrus_patternfill_src_or_dst),
 
454
    ROP2(cirrus_patternfill_notsrc_or_notdst),
 
455
    ROP2(cirrus_patternfill_src_notxor_dst),
 
456
    ROP2(cirrus_patternfill_src_or_notdst),
 
457
    ROP2(cirrus_patternfill_notsrc),
 
458
    ROP2(cirrus_patternfill_notsrc_or_dst),
 
459
    ROP2(cirrus_patternfill_notsrc_and_notdst),
 
460
};
 
461
 
 
462
static const cirrus_bitblt_rop_t cirrus_colorexpand_transp[16][4] = {
 
463
    ROP2(cirrus_colorexpand_transp_0),
 
464
    ROP2(cirrus_colorexpand_transp_src_and_dst),
 
465
    ROP_NOP2(cirrus_bitblt_rop_nop),
 
466
    ROP2(cirrus_colorexpand_transp_src_and_notdst),
 
467
    ROP2(cirrus_colorexpand_transp_notdst),
 
468
    ROP2(cirrus_colorexpand_transp_src),
 
469
    ROP2(cirrus_colorexpand_transp_1),
 
470
    ROP2(cirrus_colorexpand_transp_notsrc_and_dst),
 
471
    ROP2(cirrus_colorexpand_transp_src_xor_dst),
 
472
    ROP2(cirrus_colorexpand_transp_src_or_dst),
 
473
    ROP2(cirrus_colorexpand_transp_notsrc_or_notdst),
 
474
    ROP2(cirrus_colorexpand_transp_src_notxor_dst),
 
475
    ROP2(cirrus_colorexpand_transp_src_or_notdst),
 
476
    ROP2(cirrus_colorexpand_transp_notsrc),
 
477
    ROP2(cirrus_colorexpand_transp_notsrc_or_dst),
 
478
    ROP2(cirrus_colorexpand_transp_notsrc_and_notdst),
 
479
};
 
480
 
 
481
static const cirrus_bitblt_rop_t cirrus_colorexpand[16][4] = {
 
482
    ROP2(cirrus_colorexpand_0),
 
483
    ROP2(cirrus_colorexpand_src_and_dst),
 
484
    ROP_NOP2(cirrus_bitblt_rop_nop),
 
485
    ROP2(cirrus_colorexpand_src_and_notdst),
 
486
    ROP2(cirrus_colorexpand_notdst),
 
487
    ROP2(cirrus_colorexpand_src),
 
488
    ROP2(cirrus_colorexpand_1),
 
489
    ROP2(cirrus_colorexpand_notsrc_and_dst),
 
490
    ROP2(cirrus_colorexpand_src_xor_dst),
 
491
    ROP2(cirrus_colorexpand_src_or_dst),
 
492
    ROP2(cirrus_colorexpand_notsrc_or_notdst),
 
493
    ROP2(cirrus_colorexpand_src_notxor_dst),
 
494
    ROP2(cirrus_colorexpand_src_or_notdst),
 
495
    ROP2(cirrus_colorexpand_notsrc),
 
496
    ROP2(cirrus_colorexpand_notsrc_or_dst),
 
497
    ROP2(cirrus_colorexpand_notsrc_and_notdst),
 
498
};
 
499
 
 
500
static const cirrus_bitblt_rop_t cirrus_colorexpand_pattern_transp[16][4] = {
 
501
    ROP2(cirrus_colorexpand_pattern_transp_0),
 
502
    ROP2(cirrus_colorexpand_pattern_transp_src_and_dst),
 
503
    ROP_NOP2(cirrus_bitblt_rop_nop),
 
504
    ROP2(cirrus_colorexpand_pattern_transp_src_and_notdst),
 
505
    ROP2(cirrus_colorexpand_pattern_transp_notdst),
 
506
    ROP2(cirrus_colorexpand_pattern_transp_src),
 
507
    ROP2(cirrus_colorexpand_pattern_transp_1),
 
508
    ROP2(cirrus_colorexpand_pattern_transp_notsrc_and_dst),
 
509
    ROP2(cirrus_colorexpand_pattern_transp_src_xor_dst),
 
510
    ROP2(cirrus_colorexpand_pattern_transp_src_or_dst),
 
511
    ROP2(cirrus_colorexpand_pattern_transp_notsrc_or_notdst),
 
512
    ROP2(cirrus_colorexpand_pattern_transp_src_notxor_dst),
 
513
    ROP2(cirrus_colorexpand_pattern_transp_src_or_notdst),
 
514
    ROP2(cirrus_colorexpand_pattern_transp_notsrc),
 
515
    ROP2(cirrus_colorexpand_pattern_transp_notsrc_or_dst),
 
516
    ROP2(cirrus_colorexpand_pattern_transp_notsrc_and_notdst),
 
517
};
 
518
 
 
519
static const cirrus_bitblt_rop_t cirrus_colorexpand_pattern[16][4] = {
 
520
    ROP2(cirrus_colorexpand_pattern_0),
 
521
    ROP2(cirrus_colorexpand_pattern_src_and_dst),
 
522
    ROP_NOP2(cirrus_bitblt_rop_nop),
 
523
    ROP2(cirrus_colorexpand_pattern_src_and_notdst),
 
524
    ROP2(cirrus_colorexpand_pattern_notdst),
 
525
    ROP2(cirrus_colorexpand_pattern_src),
 
526
    ROP2(cirrus_colorexpand_pattern_1),
 
527
    ROP2(cirrus_colorexpand_pattern_notsrc_and_dst),
 
528
    ROP2(cirrus_colorexpand_pattern_src_xor_dst),
 
529
    ROP2(cirrus_colorexpand_pattern_src_or_dst),
 
530
    ROP2(cirrus_colorexpand_pattern_notsrc_or_notdst),
 
531
    ROP2(cirrus_colorexpand_pattern_src_notxor_dst),
 
532
    ROP2(cirrus_colorexpand_pattern_src_or_notdst),
 
533
    ROP2(cirrus_colorexpand_pattern_notsrc),
 
534
    ROP2(cirrus_colorexpand_pattern_notsrc_or_dst),
 
535
    ROP2(cirrus_colorexpand_pattern_notsrc_and_notdst),
 
536
};
 
537
 
 
538
static const cirrus_fill_t cirrus_fill[16][4] = {
 
539
    ROP2(cirrus_fill_0),
 
540
    ROP2(cirrus_fill_src_and_dst),
 
541
    ROP_NOP2(cirrus_bitblt_fill_nop),
 
542
    ROP2(cirrus_fill_src_and_notdst),
 
543
    ROP2(cirrus_fill_notdst),
 
544
    ROP2(cirrus_fill_src),
 
545
    ROP2(cirrus_fill_1),
 
546
    ROP2(cirrus_fill_notsrc_and_dst),
 
547
    ROP2(cirrus_fill_src_xor_dst),
 
548
    ROP2(cirrus_fill_src_or_dst),
 
549
    ROP2(cirrus_fill_notsrc_or_notdst),
 
550
    ROP2(cirrus_fill_src_notxor_dst),
 
551
    ROP2(cirrus_fill_src_or_notdst),
 
552
    ROP2(cirrus_fill_notsrc),
 
553
    ROP2(cirrus_fill_notsrc_or_dst),
 
554
    ROP2(cirrus_fill_notsrc_and_notdst),
 
555
};
 
556
 
 
557
static inline void cirrus_bitblt_fgcol(CirrusVGAState *s)
 
558
{
 
559
    unsigned int color;
 
560
    switch (s->cirrus_blt_pixelwidth) {
 
561
    case 1:
 
562
        s->cirrus_blt_fgcol = s->cirrus_shadow_gr1;
 
563
        break;
 
564
    case 2:
 
565
        color = s->cirrus_shadow_gr1 | (s->vga.gr[0x11] << 8);
 
566
        s->cirrus_blt_fgcol = le16_to_cpu(color);
 
567
        break;
 
568
    case 3:
 
569
        s->cirrus_blt_fgcol = s->cirrus_shadow_gr1 |
 
570
            (s->vga.gr[0x11] << 8) | (s->vga.gr[0x13] << 16);
 
571
        break;
 
572
    default:
 
573
    case 4:
 
574
        color = s->cirrus_shadow_gr1 | (s->vga.gr[0x11] << 8) |
 
575
            (s->vga.gr[0x13] << 16) | (s->vga.gr[0x15] << 24);
 
576
        s->cirrus_blt_fgcol = le32_to_cpu(color);
 
577
        break;
 
578
    }
 
579
}
 
580
 
 
581
static inline void cirrus_bitblt_bgcol(CirrusVGAState *s)
 
582
{
 
583
    unsigned int color;
 
584
    switch (s->cirrus_blt_pixelwidth) {
 
585
    case 1:
 
586
        s->cirrus_blt_bgcol = s->cirrus_shadow_gr0;
 
587
        break;
 
588
    case 2:
 
589
        color = s->cirrus_shadow_gr0 | (s->vga.gr[0x10] << 8);
 
590
        s->cirrus_blt_bgcol = le16_to_cpu(color);
 
591
        break;
 
592
    case 3:
 
593
        s->cirrus_blt_bgcol = s->cirrus_shadow_gr0 |
 
594
            (s->vga.gr[0x10] << 8) | (s->vga.gr[0x12] << 16);
 
595
        break;
 
596
    default:
 
597
    case 4:
 
598
        color = s->cirrus_shadow_gr0 | (s->vga.gr[0x10] << 8) |
 
599
            (s->vga.gr[0x12] << 16) | (s->vga.gr[0x14] << 24);
 
600
        s->cirrus_blt_bgcol = le32_to_cpu(color);
 
601
        break;
 
602
    }
 
603
}
 
604
 
 
605
static void cirrus_invalidate_region(CirrusVGAState * s, int off_begin,
 
606
                                     int off_pitch, int bytesperline,
 
607
                                     int lines)
 
608
{
 
609
    int y;
 
610
    int off_cur;
 
611
    int off_cur_end;
 
612
 
 
613
    for (y = 0; y < lines; y++) {
 
614
        off_cur = off_begin;
 
615
        off_cur_end = (off_cur + bytesperline) & s->cirrus_addr_mask;
 
616
        off_cur &= TARGET_PAGE_MASK;
 
617
        while (off_cur < off_cur_end) {
 
618
            memory_region_set_dirty(&s->vga.vram, off_cur);
 
619
            off_cur += TARGET_PAGE_SIZE;
 
620
        }
 
621
        off_begin += off_pitch;
 
622
    }
 
623
}
 
624
 
 
625
static int cirrus_bitblt_common_patterncopy(CirrusVGAState * s,
 
626
                                            const uint8_t * src)
 
627
{
 
628
    uint8_t *dst;
 
629
 
 
630
    dst = s->vga.vram_ptr + (s->cirrus_blt_dstaddr & s->cirrus_addr_mask);
 
631
 
 
632
    if (BLTUNSAFE(s))
 
633
        return 0;
 
634
 
 
635
    (*s->cirrus_rop) (s, dst, src,
 
636
                      s->cirrus_blt_dstpitch, 0,
 
637
                      s->cirrus_blt_width, s->cirrus_blt_height);
 
638
    cirrus_invalidate_region(s, s->cirrus_blt_dstaddr,
 
639
                             s->cirrus_blt_dstpitch, s->cirrus_blt_width,
 
640
                             s->cirrus_blt_height);
 
641
    return 1;
 
642
}
 
643
 
 
644
/* fill */
 
645
 
 
646
static int cirrus_bitblt_solidfill(CirrusVGAState *s, int blt_rop)
 
647
{
 
648
    cirrus_fill_t rop_func;
 
649
 
 
650
    if (BLTUNSAFE(s))
 
651
        return 0;
 
652
    rop_func = cirrus_fill[rop_to_index[blt_rop]][s->cirrus_blt_pixelwidth - 1];
 
653
    rop_func(s, s->vga.vram_ptr + (s->cirrus_blt_dstaddr & s->cirrus_addr_mask),
 
654
             s->cirrus_blt_dstpitch,
 
655
             s->cirrus_blt_width, s->cirrus_blt_height);
 
656
    cirrus_invalidate_region(s, s->cirrus_blt_dstaddr,
 
657
                             s->cirrus_blt_dstpitch, s->cirrus_blt_width,
 
658
                             s->cirrus_blt_height);
 
659
    cirrus_bitblt_reset(s);
 
660
    return 1;
 
661
}
 
662
 
 
663
/***************************************
 
664
 *
 
665
 *  bitblt (video-to-video)
 
666
 *
 
667
 ***************************************/
 
668
 
 
669
static int cirrus_bitblt_videotovideo_patterncopy(CirrusVGAState * s)
 
670
{
 
671
    return cirrus_bitblt_common_patterncopy(s,
 
672
                                            s->vga.vram_ptr + ((s->cirrus_blt_srcaddr & ~7) &
 
673
                                            s->cirrus_addr_mask));
 
674
}
 
675
 
 
676
static void cirrus_do_copy(CirrusVGAState *s, int dst, int src, int w, int h)
 
677
{
 
678
    int sx = 0, sy = 0;
 
679
    int dx = 0, dy = 0;
 
680
    int depth = 0;
 
681
    int notify = 0;
 
682
 
 
683
    /* make sure to only copy if it's a plain copy ROP */
 
684
    if (*s->cirrus_rop == cirrus_bitblt_rop_fwd_src ||
 
685
        *s->cirrus_rop == cirrus_bitblt_rop_bkwd_src) {
 
686
 
 
687
        int width, height;
 
688
 
 
689
        depth = s->vga.get_bpp(&s->vga) / 8;
 
690
        s->vga.get_resolution(&s->vga, &width, &height);
 
691
 
 
692
        /* extra x, y */
 
693
        sx = (src % ABS(s->cirrus_blt_srcpitch)) / depth;
 
694
        sy = (src / ABS(s->cirrus_blt_srcpitch));
 
695
        dx = (dst % ABS(s->cirrus_blt_dstpitch)) / depth;
 
696
        dy = (dst / ABS(s->cirrus_blt_dstpitch));
 
697
 
 
698
        /* normalize width */
 
699
        w /= depth;
 
700
 
 
701
        /* if we're doing a backward copy, we have to adjust
 
702
           our x/y to be the upper left corner (instead of the lower
 
703
           right corner) */
 
704
        if (s->cirrus_blt_dstpitch < 0) {
 
705
            sx -= (s->cirrus_blt_width / depth) - 1;
 
706
            dx -= (s->cirrus_blt_width / depth) - 1;
 
707
            sy -= s->cirrus_blt_height - 1;
 
708
            dy -= s->cirrus_blt_height - 1;
 
709
        }
 
710
 
 
711
        /* are we in the visible portion of memory? */
 
712
        if (sx >= 0 && sy >= 0 && dx >= 0 && dy >= 0 &&
 
713
            (sx + w) <= width && (sy + h) <= height &&
 
714
            (dx + w) <= width && (dy + h) <= height) {
 
715
            notify = 1;
 
716
        }
 
717
    }
 
718
 
 
719
    /* we have to flush all pending changes so that the copy
 
720
       is generated at the appropriate moment in time */
 
721
    if (notify)
 
722
        vga_hw_update();
 
723
 
 
724
    (*s->cirrus_rop) (s, s->vga.vram_ptr +
 
725
                      (s->cirrus_blt_dstaddr & s->cirrus_addr_mask),
 
726
                      s->vga.vram_ptr +
 
727
                      (s->cirrus_blt_srcaddr & s->cirrus_addr_mask),
 
728
                      s->cirrus_blt_dstpitch, s->cirrus_blt_srcpitch,
 
729
                      s->cirrus_blt_width, s->cirrus_blt_height);
 
730
 
 
731
    if (notify)
 
732
        qemu_console_copy(s->vga.ds,
 
733
                          sx, sy, dx, dy,
 
734
                          s->cirrus_blt_width / depth,
 
735
                          s->cirrus_blt_height);
 
736
 
 
737
    /* we don't have to notify the display that this portion has
 
738
       changed since qemu_console_copy implies this */
 
739
 
 
740
    cirrus_invalidate_region(s, s->cirrus_blt_dstaddr,
 
741
                                s->cirrus_blt_dstpitch, s->cirrus_blt_width,
 
742
                                s->cirrus_blt_height);
 
743
}
 
744
 
 
745
static int cirrus_bitblt_videotovideo_copy(CirrusVGAState * s)
 
746
{
 
747
    if (BLTUNSAFE(s))
 
748
        return 0;
 
749
 
 
750
    cirrus_do_copy(s, s->cirrus_blt_dstaddr - s->vga.start_addr,
 
751
            s->cirrus_blt_srcaddr - s->vga.start_addr,
 
752
            s->cirrus_blt_width, s->cirrus_blt_height);
 
753
 
 
754
    return 1;
 
755
}
 
756
 
 
757
/***************************************
 
758
 *
 
759
 *  bitblt (cpu-to-video)
 
760
 *
 
761
 ***************************************/
 
762
 
 
763
static void cirrus_bitblt_cputovideo_next(CirrusVGAState * s)
 
764
{
 
765
    int copy_count;
 
766
    uint8_t *end_ptr;
 
767
 
 
768
    if (s->cirrus_srccounter > 0) {
 
769
        if (s->cirrus_blt_mode & CIRRUS_BLTMODE_PATTERNCOPY) {
 
770
            cirrus_bitblt_common_patterncopy(s, s->cirrus_bltbuf);
 
771
        the_end:
 
772
            s->cirrus_srccounter = 0;
 
773
            cirrus_bitblt_reset(s);
 
774
        } else {
 
775
            /* at least one scan line */
 
776
            do {
 
777
                (*s->cirrus_rop)(s, s->vga.vram_ptr +
 
778
                                 (s->cirrus_blt_dstaddr & s->cirrus_addr_mask),
 
779
                                  s->cirrus_bltbuf, 0, 0, s->cirrus_blt_width, 1);
 
780
                cirrus_invalidate_region(s, s->cirrus_blt_dstaddr, 0,
 
781
                                         s->cirrus_blt_width, 1);
 
782
                s->cirrus_blt_dstaddr += s->cirrus_blt_dstpitch;
 
783
                s->cirrus_srccounter -= s->cirrus_blt_srcpitch;
 
784
                if (s->cirrus_srccounter <= 0)
 
785
                    goto the_end;
 
786
                /* more bytes than needed can be transfered because of
 
787
                   word alignment, so we keep them for the next line */
 
788
                /* XXX: keep alignment to speed up transfer */
 
789
                end_ptr = s->cirrus_bltbuf + s->cirrus_blt_srcpitch;
 
790
                copy_count = s->cirrus_srcptr_end - end_ptr;
 
791
                memmove(s->cirrus_bltbuf, end_ptr, copy_count);
 
792
                s->cirrus_srcptr = s->cirrus_bltbuf + copy_count;
 
793
                s->cirrus_srcptr_end = s->cirrus_bltbuf + s->cirrus_blt_srcpitch;
 
794
            } while (s->cirrus_srcptr >= s->cirrus_srcptr_end);
 
795
        }
 
796
    }
 
797
}
 
798
 
 
799
/***************************************
 
800
 *
 
801
 *  bitblt wrapper
 
802
 *
 
803
 ***************************************/
 
804
 
 
805
static void cirrus_bitblt_reset(CirrusVGAState * s)
 
806
{
 
807
    int need_update;
 
808
 
 
809
    s->vga.gr[0x31] &=
 
810
        ~(CIRRUS_BLT_START | CIRRUS_BLT_BUSY | CIRRUS_BLT_FIFOUSED);
 
811
    need_update = s->cirrus_srcptr != &s->cirrus_bltbuf[0]
 
812
        || s->cirrus_srcptr_end != &s->cirrus_bltbuf[0];
 
813
    s->cirrus_srcptr = &s->cirrus_bltbuf[0];
 
814
    s->cirrus_srcptr_end = &s->cirrus_bltbuf[0];
 
815
    s->cirrus_srccounter = 0;
 
816
    if (!need_update)
 
817
        return;
 
818
    cirrus_update_memory_access(s);
 
819
}
 
820
 
 
821
static int cirrus_bitblt_cputovideo(CirrusVGAState * s)
 
822
{
 
823
    int w;
 
824
 
 
825
    s->cirrus_blt_mode &= ~CIRRUS_BLTMODE_MEMSYSSRC;
 
826
    s->cirrus_srcptr = &s->cirrus_bltbuf[0];
 
827
    s->cirrus_srcptr_end = &s->cirrus_bltbuf[0];
 
828
 
 
829
    if (s->cirrus_blt_mode & CIRRUS_BLTMODE_PATTERNCOPY) {
 
830
        if (s->cirrus_blt_mode & CIRRUS_BLTMODE_COLOREXPAND) {
 
831
            s->cirrus_blt_srcpitch = 8;
 
832
        } else {
 
833
            /* XXX: check for 24 bpp */
 
834
            s->cirrus_blt_srcpitch = 8 * 8 * s->cirrus_blt_pixelwidth;
 
835
        }
 
836
        s->cirrus_srccounter = s->cirrus_blt_srcpitch;
 
837
    } else {
 
838
        if (s->cirrus_blt_mode & CIRRUS_BLTMODE_COLOREXPAND) {
 
839
            w = s->cirrus_blt_width / s->cirrus_blt_pixelwidth;
 
840
            if (s->cirrus_blt_modeext & CIRRUS_BLTMODEEXT_DWORDGRANULARITY)
 
841
                s->cirrus_blt_srcpitch = ((w + 31) >> 5);
 
842
            else
 
843
                s->cirrus_blt_srcpitch = ((w + 7) >> 3);
 
844
        } else {
 
845
            /* always align input size to 32 bits */
 
846
            s->cirrus_blt_srcpitch = (s->cirrus_blt_width + 3) & ~3;
 
847
        }
 
848
        s->cirrus_srccounter = s->cirrus_blt_srcpitch * s->cirrus_blt_height;
 
849
    }
 
850
    s->cirrus_srcptr = s->cirrus_bltbuf;
 
851
    s->cirrus_srcptr_end = s->cirrus_bltbuf + s->cirrus_blt_srcpitch;
 
852
    cirrus_update_memory_access(s);
 
853
    return 1;
 
854
}
 
855
 
 
856
static int cirrus_bitblt_videotocpu(CirrusVGAState * s)
 
857
{
 
858
    /* XXX */
 
859
#ifdef DEBUG_BITBLT
 
860
    printf("cirrus: bitblt (video to cpu) is not implemented yet\n");
 
861
#endif
 
862
    return 0;
 
863
}
 
864
 
 
865
static int cirrus_bitblt_videotovideo(CirrusVGAState * s)
 
866
{
 
867
    int ret;
 
868
 
 
869
    if (s->cirrus_blt_mode & CIRRUS_BLTMODE_PATTERNCOPY) {
 
870
        ret = cirrus_bitblt_videotovideo_patterncopy(s);
 
871
    } else {
 
872
        ret = cirrus_bitblt_videotovideo_copy(s);
 
873
    }
 
874
    if (ret)
 
875
        cirrus_bitblt_reset(s);
 
876
    return ret;
 
877
}
 
878
 
 
879
static void cirrus_bitblt_start(CirrusVGAState * s)
 
880
{
 
881
    uint8_t blt_rop;
 
882
 
 
883
    s->vga.gr[0x31] |= CIRRUS_BLT_BUSY;
 
884
 
 
885
    s->cirrus_blt_width = (s->vga.gr[0x20] | (s->vga.gr[0x21] << 8)) + 1;
 
886
    s->cirrus_blt_height = (s->vga.gr[0x22] | (s->vga.gr[0x23] << 8)) + 1;
 
887
    s->cirrus_blt_dstpitch = (s->vga.gr[0x24] | (s->vga.gr[0x25] << 8));
 
888
    s->cirrus_blt_srcpitch = (s->vga.gr[0x26] | (s->vga.gr[0x27] << 8));
 
889
    s->cirrus_blt_dstaddr =
 
890
        (s->vga.gr[0x28] | (s->vga.gr[0x29] << 8) | (s->vga.gr[0x2a] << 16));
 
891
    s->cirrus_blt_srcaddr =
 
892
        (s->vga.gr[0x2c] | (s->vga.gr[0x2d] << 8) | (s->vga.gr[0x2e] << 16));
 
893
    s->cirrus_blt_mode = s->vga.gr[0x30];
 
894
    s->cirrus_blt_modeext = s->vga.gr[0x33];
 
895
    blt_rop = s->vga.gr[0x32];
 
896
 
 
897
#ifdef DEBUG_BITBLT
 
898
    printf("rop=0x%02x mode=0x%02x modeext=0x%02x w=%d h=%d dpitch=%d spitch=%d daddr=0x%08x saddr=0x%08x writemask=0x%02x\n",
 
899
           blt_rop,
 
900
           s->cirrus_blt_mode,
 
901
           s->cirrus_blt_modeext,
 
902
           s->cirrus_blt_width,
 
903
           s->cirrus_blt_height,
 
904
           s->cirrus_blt_dstpitch,
 
905
           s->cirrus_blt_srcpitch,
 
906
           s->cirrus_blt_dstaddr,
 
907
           s->cirrus_blt_srcaddr,
 
908
           s->vga.gr[0x2f]);
 
909
#endif
 
910
 
 
911
    switch (s->cirrus_blt_mode & CIRRUS_BLTMODE_PIXELWIDTHMASK) {
 
912
    case CIRRUS_BLTMODE_PIXELWIDTH8:
 
913
        s->cirrus_blt_pixelwidth = 1;
 
914
        break;
 
915
    case CIRRUS_BLTMODE_PIXELWIDTH16:
 
916
        s->cirrus_blt_pixelwidth = 2;
 
917
        break;
 
918
    case CIRRUS_BLTMODE_PIXELWIDTH24:
 
919
        s->cirrus_blt_pixelwidth = 3;
 
920
        break;
 
921
    case CIRRUS_BLTMODE_PIXELWIDTH32:
 
922
        s->cirrus_blt_pixelwidth = 4;
 
923
        break;
 
924
    default:
 
925
#ifdef DEBUG_BITBLT
 
926
        printf("cirrus: bitblt - pixel width is unknown\n");
 
927
#endif
 
928
        goto bitblt_ignore;
 
929
    }
 
930
    s->cirrus_blt_mode &= ~CIRRUS_BLTMODE_PIXELWIDTHMASK;
 
931
 
 
932
    if ((s->
 
933
         cirrus_blt_mode & (CIRRUS_BLTMODE_MEMSYSSRC |
 
934
                            CIRRUS_BLTMODE_MEMSYSDEST))
 
935
        == (CIRRUS_BLTMODE_MEMSYSSRC | CIRRUS_BLTMODE_MEMSYSDEST)) {
 
936
#ifdef DEBUG_BITBLT
 
937
        printf("cirrus: bitblt - memory-to-memory copy is requested\n");
 
938
#endif
 
939
        goto bitblt_ignore;
 
940
    }
 
941
 
 
942
    if ((s->cirrus_blt_modeext & CIRRUS_BLTMODEEXT_SOLIDFILL) &&
 
943
        (s->cirrus_blt_mode & (CIRRUS_BLTMODE_MEMSYSDEST |
 
944
                               CIRRUS_BLTMODE_TRANSPARENTCOMP |
 
945
                               CIRRUS_BLTMODE_PATTERNCOPY |
 
946
                               CIRRUS_BLTMODE_COLOREXPAND)) ==
 
947
         (CIRRUS_BLTMODE_PATTERNCOPY | CIRRUS_BLTMODE_COLOREXPAND)) {
 
948
        cirrus_bitblt_fgcol(s);
 
949
        cirrus_bitblt_solidfill(s, blt_rop);
 
950
    } else {
 
951
        if ((s->cirrus_blt_mode & (CIRRUS_BLTMODE_COLOREXPAND |
 
952
                                   CIRRUS_BLTMODE_PATTERNCOPY)) ==
 
953
            CIRRUS_BLTMODE_COLOREXPAND) {
 
954
 
 
955
            if (s->cirrus_blt_mode & CIRRUS_BLTMODE_TRANSPARENTCOMP) {
 
956
                if (s->cirrus_blt_modeext & CIRRUS_BLTMODEEXT_COLOREXPINV)
 
957
                    cirrus_bitblt_bgcol(s);
 
958
                else
 
959
                    cirrus_bitblt_fgcol(s);
 
960
                s->cirrus_rop = cirrus_colorexpand_transp[rop_to_index[blt_rop]][s->cirrus_blt_pixelwidth - 1];
 
961
            } else {
 
962
                cirrus_bitblt_fgcol(s);
 
963
                cirrus_bitblt_bgcol(s);
 
964
                s->cirrus_rop = cirrus_colorexpand[rop_to_index[blt_rop]][s->cirrus_blt_pixelwidth - 1];
 
965
            }
 
966
        } else if (s->cirrus_blt_mode & CIRRUS_BLTMODE_PATTERNCOPY) {
 
967
            if (s->cirrus_blt_mode & CIRRUS_BLTMODE_COLOREXPAND) {
 
968
                if (s->cirrus_blt_mode & CIRRUS_BLTMODE_TRANSPARENTCOMP) {
 
969
                    if (s->cirrus_blt_modeext & CIRRUS_BLTMODEEXT_COLOREXPINV)
 
970
                        cirrus_bitblt_bgcol(s);
 
971
                    else
 
972
                        cirrus_bitblt_fgcol(s);
 
973
                    s->cirrus_rop = cirrus_colorexpand_pattern_transp[rop_to_index[blt_rop]][s->cirrus_blt_pixelwidth - 1];
 
974
                } else {
 
975
                    cirrus_bitblt_fgcol(s);
 
976
                    cirrus_bitblt_bgcol(s);
 
977
                    s->cirrus_rop = cirrus_colorexpand_pattern[rop_to_index[blt_rop]][s->cirrus_blt_pixelwidth - 1];
 
978
                }
 
979
            } else {
 
980
                s->cirrus_rop = cirrus_patternfill[rop_to_index[blt_rop]][s->cirrus_blt_pixelwidth - 1];
 
981
            }
 
982
        } else {
 
983
            if (s->cirrus_blt_mode & CIRRUS_BLTMODE_TRANSPARENTCOMP) {
 
984
                if (s->cirrus_blt_pixelwidth > 2) {
 
985
                    printf("src transparent without colorexpand must be 8bpp or 16bpp\n");
 
986
                    goto bitblt_ignore;
 
987
                }
 
988
                if (s->cirrus_blt_mode & CIRRUS_BLTMODE_BACKWARDS) {
 
989
                    s->cirrus_blt_dstpitch = -s->cirrus_blt_dstpitch;
 
990
                    s->cirrus_blt_srcpitch = -s->cirrus_blt_srcpitch;
 
991
                    s->cirrus_rop = cirrus_bkwd_transp_rop[rop_to_index[blt_rop]][s->cirrus_blt_pixelwidth - 1];
 
992
                } else {
 
993
                    s->cirrus_rop = cirrus_fwd_transp_rop[rop_to_index[blt_rop]][s->cirrus_blt_pixelwidth - 1];
 
994
                }
 
995
            } else {
 
996
                if (s->cirrus_blt_mode & CIRRUS_BLTMODE_BACKWARDS) {
 
997
                    s->cirrus_blt_dstpitch = -s->cirrus_blt_dstpitch;
 
998
                    s->cirrus_blt_srcpitch = -s->cirrus_blt_srcpitch;
 
999
                    s->cirrus_rop = cirrus_bkwd_rop[rop_to_index[blt_rop]];
 
1000
                } else {
 
1001
                    s->cirrus_rop = cirrus_fwd_rop[rop_to_index[blt_rop]];
 
1002
                }
 
1003
            }
 
1004
        }
 
1005
        // setup bitblt engine.
 
1006
        if (s->cirrus_blt_mode & CIRRUS_BLTMODE_MEMSYSSRC) {
 
1007
            if (!cirrus_bitblt_cputovideo(s))
 
1008
                goto bitblt_ignore;
 
1009
        } else if (s->cirrus_blt_mode & CIRRUS_BLTMODE_MEMSYSDEST) {
 
1010
            if (!cirrus_bitblt_videotocpu(s))
 
1011
                goto bitblt_ignore;
 
1012
        } else {
 
1013
            if (!cirrus_bitblt_videotovideo(s))
 
1014
                goto bitblt_ignore;
 
1015
        }
 
1016
    }
 
1017
    return;
 
1018
  bitblt_ignore:;
 
1019
    cirrus_bitblt_reset(s);
 
1020
}
 
1021
 
 
1022
static void cirrus_write_bitblt(CirrusVGAState * s, unsigned reg_value)
 
1023
{
 
1024
    unsigned old_value;
 
1025
 
 
1026
    old_value = s->vga.gr[0x31];
 
1027
    s->vga.gr[0x31] = reg_value;
 
1028
 
 
1029
    if (((old_value & CIRRUS_BLT_RESET) != 0) &&
 
1030
        ((reg_value & CIRRUS_BLT_RESET) == 0)) {
 
1031
        cirrus_bitblt_reset(s);
 
1032
    } else if (((old_value & CIRRUS_BLT_START) == 0) &&
 
1033
               ((reg_value & CIRRUS_BLT_START) != 0)) {
 
1034
        cirrus_bitblt_start(s);
 
1035
    }
 
1036
}
 
1037
 
 
1038
 
 
1039
/***************************************
 
1040
 *
 
1041
 *  basic parameters
 
1042
 *
 
1043
 ***************************************/
 
1044
 
 
1045
static void cirrus_get_offsets(VGACommonState *s1,
 
1046
                               uint32_t *pline_offset,
 
1047
                               uint32_t *pstart_addr,
 
1048
                               uint32_t *pline_compare)
 
1049
{
 
1050
    CirrusVGAState * s = container_of(s1, CirrusVGAState, vga);
 
1051
    uint32_t start_addr, line_offset, line_compare;
 
1052
 
 
1053
    line_offset = s->vga.cr[0x13]
 
1054
        | ((s->vga.cr[0x1b] & 0x10) << 4);
 
1055
    line_offset <<= 3;
 
1056
    *pline_offset = line_offset;
 
1057
 
 
1058
    start_addr = (s->vga.cr[0x0c] << 8)
 
1059
        | s->vga.cr[0x0d]
 
1060
        | ((s->vga.cr[0x1b] & 0x01) << 16)
 
1061
        | ((s->vga.cr[0x1b] & 0x0c) << 15)
 
1062
        | ((s->vga.cr[0x1d] & 0x80) << 12);
 
1063
    *pstart_addr = start_addr;
 
1064
 
 
1065
    line_compare = s->vga.cr[0x18] |
 
1066
        ((s->vga.cr[0x07] & 0x10) << 4) |
 
1067
        ((s->vga.cr[0x09] & 0x40) << 3);
 
1068
    *pline_compare = line_compare;
 
1069
}
 
1070
 
 
1071
static uint32_t cirrus_get_bpp16_depth(CirrusVGAState * s)
 
1072
{
 
1073
    uint32_t ret = 16;
 
1074
 
 
1075
    switch (s->cirrus_hidden_dac_data & 0xf) {
 
1076
    case 0:
 
1077
        ret = 15;
 
1078
        break;                  /* Sierra HiColor */
 
1079
    case 1:
 
1080
        ret = 16;
 
1081
        break;                  /* XGA HiColor */
 
1082
    default:
 
1083
#ifdef DEBUG_CIRRUS
 
1084
        printf("cirrus: invalid DAC value %x in 16bpp\n",
 
1085
               (s->cirrus_hidden_dac_data & 0xf));
 
1086
#endif
 
1087
        ret = 15;               /* XXX */
 
1088
        break;
 
1089
    }
 
1090
    return ret;
 
1091
}
 
1092
 
 
1093
static int cirrus_get_bpp(VGACommonState *s1)
 
1094
{
 
1095
    CirrusVGAState * s = container_of(s1, CirrusVGAState, vga);
 
1096
    uint32_t ret = 8;
 
1097
 
 
1098
    if ((s->vga.sr[0x07] & 0x01) != 0) {
 
1099
        /* Cirrus SVGA */
 
1100
        switch (s->vga.sr[0x07] & CIRRUS_SR7_BPP_MASK) {
 
1101
        case CIRRUS_SR7_BPP_8:
 
1102
            ret = 8;
 
1103
            break;
 
1104
        case CIRRUS_SR7_BPP_16_DOUBLEVCLK:
 
1105
            ret = cirrus_get_bpp16_depth(s);
 
1106
            break;
 
1107
        case CIRRUS_SR7_BPP_24:
 
1108
            ret = 24;
 
1109
            break;
 
1110
        case CIRRUS_SR7_BPP_16:
 
1111
            ret = cirrus_get_bpp16_depth(s);
 
1112
            break;
 
1113
        case CIRRUS_SR7_BPP_32:
 
1114
            ret = 32;
 
1115
            break;
 
1116
        default:
 
1117
#ifdef DEBUG_CIRRUS
 
1118
            printf("cirrus: unknown bpp - sr7=%x\n", s->vga.sr[0x7]);
 
1119
#endif
 
1120
            ret = 8;
 
1121
            break;
 
1122
        }
 
1123
    } else {
 
1124
        /* VGA */
 
1125
        ret = 0;
 
1126
    }
 
1127
 
 
1128
    return ret;
 
1129
}
 
1130
 
 
1131
static void cirrus_get_resolution(VGACommonState *s, int *pwidth, int *pheight)
 
1132
{
 
1133
    int width, height;
 
1134
 
 
1135
    width = (s->cr[0x01] + 1) * 8;
 
1136
    height = s->cr[0x12] |
 
1137
        ((s->cr[0x07] & 0x02) << 7) |
 
1138
        ((s->cr[0x07] & 0x40) << 3);
 
1139
    height = (height + 1);
 
1140
    /* interlace support */
 
1141
    if (s->cr[0x1a] & 0x01)
 
1142
        height = height * 2;
 
1143
    *pwidth = width;
 
1144
    *pheight = height;
 
1145
}
 
1146
 
 
1147
/***************************************
 
1148
 *
 
1149
 * bank memory
 
1150
 *
 
1151
 ***************************************/
 
1152
 
 
1153
static void cirrus_update_bank_ptr(CirrusVGAState * s, unsigned bank_index)
 
1154
{
 
1155
    unsigned offset;
 
1156
    unsigned limit;
 
1157
 
 
1158
    if ((s->vga.gr[0x0b] & 0x01) != 0)  /* dual bank */
 
1159
        offset = s->vga.gr[0x09 + bank_index];
 
1160
    else                        /* single bank */
 
1161
        offset = s->vga.gr[0x09];
 
1162
 
 
1163
    if ((s->vga.gr[0x0b] & 0x20) != 0)
 
1164
        offset <<= 14;
 
1165
    else
 
1166
        offset <<= 12;
 
1167
 
 
1168
    if (s->real_vram_size <= offset)
 
1169
        limit = 0;
 
1170
    else
 
1171
        limit = s->real_vram_size - offset;
 
1172
 
 
1173
    if (((s->vga.gr[0x0b] & 0x01) == 0) && (bank_index != 0)) {
 
1174
        if (limit > 0x8000) {
 
1175
            offset += 0x8000;
 
1176
            limit -= 0x8000;
 
1177
        } else {
 
1178
            limit = 0;
 
1179
        }
 
1180
    }
 
1181
 
 
1182
    if (limit > 0) {
 
1183
        s->cirrus_bank_base[bank_index] = offset;
 
1184
        s->cirrus_bank_limit[bank_index] = limit;
 
1185
    } else {
 
1186
        s->cirrus_bank_base[bank_index] = 0;
 
1187
        s->cirrus_bank_limit[bank_index] = 0;
 
1188
    }
 
1189
}
 
1190
 
 
1191
/***************************************
 
1192
 *
 
1193
 *  I/O access between 0x3c4-0x3c5
 
1194
 *
 
1195
 ***************************************/
 
1196
 
 
1197
static int cirrus_vga_read_sr(CirrusVGAState * s)
 
1198
{
 
1199
    switch (s->vga.sr_index) {
 
1200
    case 0x00:                  // Standard VGA
 
1201
    case 0x01:                  // Standard VGA
 
1202
    case 0x02:                  // Standard VGA
 
1203
    case 0x03:                  // Standard VGA
 
1204
    case 0x04:                  // Standard VGA
 
1205
        return s->vga.sr[s->vga.sr_index];
 
1206
    case 0x06:                  // Unlock Cirrus extensions
 
1207
        return s->vga.sr[s->vga.sr_index];
 
1208
    case 0x10:
 
1209
    case 0x30:
 
1210
    case 0x50:
 
1211
    case 0x70:                  // Graphics Cursor X
 
1212
    case 0x90:
 
1213
    case 0xb0:
 
1214
    case 0xd0:
 
1215
    case 0xf0:                  // Graphics Cursor X
 
1216
        return s->vga.sr[0x10];
 
1217
    case 0x11:
 
1218
    case 0x31:
 
1219
    case 0x51:
 
1220
    case 0x71:                  // Graphics Cursor Y
 
1221
    case 0x91:
 
1222
    case 0xb1:
 
1223
    case 0xd1:
 
1224
    case 0xf1:                  // Graphics Cursor Y
 
1225
        return s->vga.sr[0x11];
 
1226
    case 0x05:                  // ???
 
1227
    case 0x07:                  // Extended Sequencer Mode
 
1228
    case 0x08:                  // EEPROM Control
 
1229
    case 0x09:                  // Scratch Register 0
 
1230
    case 0x0a:                  // Scratch Register 1
 
1231
    case 0x0b:                  // VCLK 0
 
1232
    case 0x0c:                  // VCLK 1
 
1233
    case 0x0d:                  // VCLK 2
 
1234
    case 0x0e:                  // VCLK 3
 
1235
    case 0x0f:                  // DRAM Control
 
1236
    case 0x12:                  // Graphics Cursor Attribute
 
1237
    case 0x13:                  // Graphics Cursor Pattern Address
 
1238
    case 0x14:                  // Scratch Register 2
 
1239
    case 0x15:                  // Scratch Register 3
 
1240
    case 0x16:                  // Performance Tuning Register
 
1241
    case 0x17:                  // Configuration Readback and Extended Control
 
1242
    case 0x18:                  // Signature Generator Control
 
1243
    case 0x19:                  // Signal Generator Result
 
1244
    case 0x1a:                  // Signal Generator Result
 
1245
    case 0x1b:                  // VCLK 0 Denominator & Post
 
1246
    case 0x1c:                  // VCLK 1 Denominator & Post
 
1247
    case 0x1d:                  // VCLK 2 Denominator & Post
 
1248
    case 0x1e:                  // VCLK 3 Denominator & Post
 
1249
    case 0x1f:                  // BIOS Write Enable and MCLK select
 
1250
#ifdef DEBUG_CIRRUS
 
1251
        printf("cirrus: handled inport sr_index %02x\n", s->vga.sr_index);
 
1252
#endif
 
1253
        return s->vga.sr[s->vga.sr_index];
 
1254
    default:
 
1255
#ifdef DEBUG_CIRRUS
 
1256
        printf("cirrus: inport sr_index %02x\n", s->vga.sr_index);
 
1257
#endif
 
1258
        return 0xff;
 
1259
        break;
 
1260
    }
 
1261
}
 
1262
 
 
1263
static void cirrus_vga_write_sr(CirrusVGAState * s, uint32_t val)
 
1264
{
 
1265
    switch (s->vga.sr_index) {
 
1266
    case 0x00:                  // Standard VGA
 
1267
    case 0x01:                  // Standard VGA
 
1268
    case 0x02:                  // Standard VGA
 
1269
    case 0x03:                  // Standard VGA
 
1270
    case 0x04:                  // Standard VGA
 
1271
        s->vga.sr[s->vga.sr_index] = val & sr_mask[s->vga.sr_index];
 
1272
        if (s->vga.sr_index == 1)
 
1273
            s->vga.update_retrace_info(&s->vga);
 
1274
        break;
 
1275
    case 0x06:                  // Unlock Cirrus extensions
 
1276
        val &= 0x17;
 
1277
        if (val == 0x12) {
 
1278
            s->vga.sr[s->vga.sr_index] = 0x12;
 
1279
        } else {
 
1280
            s->vga.sr[s->vga.sr_index] = 0x0f;
 
1281
        }
 
1282
        break;
 
1283
    case 0x10:
 
1284
    case 0x30:
 
1285
    case 0x50:
 
1286
    case 0x70:                  // Graphics Cursor X
 
1287
    case 0x90:
 
1288
    case 0xb0:
 
1289
    case 0xd0:
 
1290
    case 0xf0:                  // Graphics Cursor X
 
1291
        s->vga.sr[0x10] = val;
 
1292
        s->hw_cursor_x = (val << 3) | (s->vga.sr_index >> 5);
 
1293
        break;
 
1294
    case 0x11:
 
1295
    case 0x31:
 
1296
    case 0x51:
 
1297
    case 0x71:                  // Graphics Cursor Y
 
1298
    case 0x91:
 
1299
    case 0xb1:
 
1300
    case 0xd1:
 
1301
    case 0xf1:                  // Graphics Cursor Y
 
1302
        s->vga.sr[0x11] = val;
 
1303
        s->hw_cursor_y = (val << 3) | (s->vga.sr_index >> 5);
 
1304
        break;
 
1305
    case 0x07:                  // Extended Sequencer Mode
 
1306
    cirrus_update_memory_access(s);
 
1307
    case 0x08:                  // EEPROM Control
 
1308
    case 0x09:                  // Scratch Register 0
 
1309
    case 0x0a:                  // Scratch Register 1
 
1310
    case 0x0b:                  // VCLK 0
 
1311
    case 0x0c:                  // VCLK 1
 
1312
    case 0x0d:                  // VCLK 2
 
1313
    case 0x0e:                  // VCLK 3
 
1314
    case 0x0f:                  // DRAM Control
 
1315
    case 0x12:                  // Graphics Cursor Attribute
 
1316
    case 0x13:                  // Graphics Cursor Pattern Address
 
1317
    case 0x14:                  // Scratch Register 2
 
1318
    case 0x15:                  // Scratch Register 3
 
1319
    case 0x16:                  // Performance Tuning Register
 
1320
    case 0x18:                  // Signature Generator Control
 
1321
    case 0x19:                  // Signature Generator Result
 
1322
    case 0x1a:                  // Signature Generator Result
 
1323
    case 0x1b:                  // VCLK 0 Denominator & Post
 
1324
    case 0x1c:                  // VCLK 1 Denominator & Post
 
1325
    case 0x1d:                  // VCLK 2 Denominator & Post
 
1326
    case 0x1e:                  // VCLK 3 Denominator & Post
 
1327
    case 0x1f:                  // BIOS Write Enable and MCLK select
 
1328
        s->vga.sr[s->vga.sr_index] = val;
 
1329
#ifdef DEBUG_CIRRUS
 
1330
        printf("cirrus: handled outport sr_index %02x, sr_value %02x\n",
 
1331
               s->vga.sr_index, val);
 
1332
#endif
 
1333
        break;
 
1334
    case 0x17:                  // Configuration Readback and Extended Control
 
1335
        s->vga.sr[s->vga.sr_index] = (s->vga.sr[s->vga.sr_index] & 0x38)
 
1336
                                   | (val & 0xc7);
 
1337
        cirrus_update_memory_access(s);
 
1338
        break;
 
1339
    default:
 
1340
#ifdef DEBUG_CIRRUS
 
1341
        printf("cirrus: outport sr_index %02x, sr_value %02x\n",
 
1342
               s->vga.sr_index, val);
 
1343
#endif
 
1344
        break;
 
1345
    }
 
1346
}
 
1347
 
 
1348
/***************************************
 
1349
 *
 
1350
 *  I/O access at 0x3c6
 
1351
 *
 
1352
 ***************************************/
 
1353
 
 
1354
static int cirrus_read_hidden_dac(CirrusVGAState * s)
 
1355
{
 
1356
    if (++s->cirrus_hidden_dac_lockindex == 5) {
 
1357
        s->cirrus_hidden_dac_lockindex = 0;
 
1358
        return s->cirrus_hidden_dac_data;
 
1359
    }
 
1360
    return 0xff;
 
1361
}
 
1362
 
 
1363
static void cirrus_write_hidden_dac(CirrusVGAState * s, int reg_value)
 
1364
{
 
1365
    if (s->cirrus_hidden_dac_lockindex == 4) {
 
1366
        s->cirrus_hidden_dac_data = reg_value;
 
1367
#if defined(DEBUG_CIRRUS)
 
1368
        printf("cirrus: outport hidden DAC, value %02x\n", reg_value);
 
1369
#endif
 
1370
    }
 
1371
    s->cirrus_hidden_dac_lockindex = 0;
 
1372
}
 
1373
 
 
1374
/***************************************
 
1375
 *
 
1376
 *  I/O access at 0x3c9
 
1377
 *
 
1378
 ***************************************/
 
1379
 
 
1380
static int cirrus_vga_read_palette(CirrusVGAState * s)
 
1381
{
 
1382
    int val;
 
1383
 
 
1384
    if ((s->vga.sr[0x12] & CIRRUS_CURSOR_HIDDENPEL)) {
 
1385
        val = s->cirrus_hidden_palette[(s->vga.dac_read_index & 0x0f) * 3 +
 
1386
                                       s->vga.dac_sub_index];
 
1387
    } else {
 
1388
        val = s->vga.palette[s->vga.dac_read_index * 3 + s->vga.dac_sub_index];
 
1389
    }
 
1390
    if (++s->vga.dac_sub_index == 3) {
 
1391
        s->vga.dac_sub_index = 0;
 
1392
        s->vga.dac_read_index++;
 
1393
    }
 
1394
    return val;
 
1395
}
 
1396
 
 
1397
static void cirrus_vga_write_palette(CirrusVGAState * s, int reg_value)
 
1398
{
 
1399
    s->vga.dac_cache[s->vga.dac_sub_index] = reg_value;
 
1400
    if (++s->vga.dac_sub_index == 3) {
 
1401
        if ((s->vga.sr[0x12] & CIRRUS_CURSOR_HIDDENPEL)) {
 
1402
            memcpy(&s->cirrus_hidden_palette[(s->vga.dac_write_index & 0x0f) * 3],
 
1403
                   s->vga.dac_cache, 3);
 
1404
        } else {
 
1405
            memcpy(&s->vga.palette[s->vga.dac_write_index * 3], s->vga.dac_cache, 3);
 
1406
        }
 
1407
        /* XXX update cursor */
 
1408
        s->vga.dac_sub_index = 0;
 
1409
        s->vga.dac_write_index++;
 
1410
    }
 
1411
}
 
1412
 
 
1413
/***************************************
 
1414
 *
 
1415
 *  I/O access between 0x3ce-0x3cf
 
1416
 *
 
1417
 ***************************************/
 
1418
 
 
1419
static int cirrus_vga_read_gr(CirrusVGAState * s, unsigned reg_index)
 
1420
{
 
1421
    switch (reg_index) {
 
1422
    case 0x00: // Standard VGA, BGCOLOR 0x000000ff
 
1423
        return s->cirrus_shadow_gr0;
 
1424
    case 0x01: // Standard VGA, FGCOLOR 0x000000ff
 
1425
        return s->cirrus_shadow_gr1;
 
1426
    case 0x02:                  // Standard VGA
 
1427
    case 0x03:                  // Standard VGA
 
1428
    case 0x04:                  // Standard VGA
 
1429
    case 0x06:                  // Standard VGA
 
1430
    case 0x07:                  // Standard VGA
 
1431
    case 0x08:                  // Standard VGA
 
1432
        return s->vga.gr[s->vga.gr_index];
 
1433
    case 0x05:                  // Standard VGA, Cirrus extended mode
 
1434
    default:
 
1435
        break;
 
1436
    }
 
1437
 
 
1438
    if (reg_index < 0x3a) {
 
1439
        return s->vga.gr[reg_index];
 
1440
    } else {
 
1441
#ifdef DEBUG_CIRRUS
 
1442
        printf("cirrus: inport gr_index %02x\n", reg_index);
 
1443
#endif
 
1444
        return 0xff;
 
1445
    }
 
1446
}
 
1447
 
 
1448
static void
 
1449
cirrus_vga_write_gr(CirrusVGAState * s, unsigned reg_index, int reg_value)
 
1450
{
 
1451
#if defined(DEBUG_BITBLT) && 0
 
1452
    printf("gr%02x: %02x\n", reg_index, reg_value);
 
1453
#endif
 
1454
    switch (reg_index) {
 
1455
    case 0x00:                  // Standard VGA, BGCOLOR 0x000000ff
 
1456
        s->vga.gr[reg_index] = reg_value & gr_mask[reg_index];
 
1457
        s->cirrus_shadow_gr0 = reg_value;
 
1458
        break;
 
1459
    case 0x01:                  // Standard VGA, FGCOLOR 0x000000ff
 
1460
        s->vga.gr[reg_index] = reg_value & gr_mask[reg_index];
 
1461
        s->cirrus_shadow_gr1 = reg_value;
 
1462
        break;
 
1463
    case 0x02:                  // Standard VGA
 
1464
    case 0x03:                  // Standard VGA
 
1465
    case 0x04:                  // Standard VGA
 
1466
    case 0x06:                  // Standard VGA
 
1467
    case 0x07:                  // Standard VGA
 
1468
    case 0x08:                  // Standard VGA
 
1469
        s->vga.gr[reg_index] = reg_value & gr_mask[reg_index];
 
1470
        break;
 
1471
    case 0x05:                  // Standard VGA, Cirrus extended mode
 
1472
        s->vga.gr[reg_index] = reg_value & 0x7f;
 
1473
        cirrus_update_memory_access(s);
 
1474
        break;
 
1475
    case 0x09:                  // bank offset #0
 
1476
    case 0x0A:                  // bank offset #1
 
1477
        s->vga.gr[reg_index] = reg_value;
 
1478
        cirrus_update_bank_ptr(s, 0);
 
1479
        cirrus_update_bank_ptr(s, 1);
 
1480
        cirrus_update_memory_access(s);
 
1481
        break;
 
1482
    case 0x0B:
 
1483
        s->vga.gr[reg_index] = reg_value;
 
1484
        cirrus_update_bank_ptr(s, 0);
 
1485
        cirrus_update_bank_ptr(s, 1);
 
1486
        cirrus_update_memory_access(s);
 
1487
        break;
 
1488
    case 0x10:                  // BGCOLOR 0x0000ff00
 
1489
    case 0x11:                  // FGCOLOR 0x0000ff00
 
1490
    case 0x12:                  // BGCOLOR 0x00ff0000
 
1491
    case 0x13:                  // FGCOLOR 0x00ff0000
 
1492
    case 0x14:                  // BGCOLOR 0xff000000
 
1493
    case 0x15:                  // FGCOLOR 0xff000000
 
1494
    case 0x20:                  // BLT WIDTH 0x0000ff
 
1495
    case 0x22:                  // BLT HEIGHT 0x0000ff
 
1496
    case 0x24:                  // BLT DEST PITCH 0x0000ff
 
1497
    case 0x26:                  // BLT SRC PITCH 0x0000ff
 
1498
    case 0x28:                  // BLT DEST ADDR 0x0000ff
 
1499
    case 0x29:                  // BLT DEST ADDR 0x00ff00
 
1500
    case 0x2c:                  // BLT SRC ADDR 0x0000ff
 
1501
    case 0x2d:                  // BLT SRC ADDR 0x00ff00
 
1502
    case 0x2f:                  // BLT WRITEMASK
 
1503
    case 0x30:                  // BLT MODE
 
1504
    case 0x32:                  // RASTER OP
 
1505
    case 0x33:                  // BLT MODEEXT
 
1506
    case 0x34:                  // BLT TRANSPARENT COLOR 0x00ff
 
1507
    case 0x35:                  // BLT TRANSPARENT COLOR 0xff00
 
1508
    case 0x38:                  // BLT TRANSPARENT COLOR MASK 0x00ff
 
1509
    case 0x39:                  // BLT TRANSPARENT COLOR MASK 0xff00
 
1510
        s->vga.gr[reg_index] = reg_value;
 
1511
        break;
 
1512
    case 0x21:                  // BLT WIDTH 0x001f00
 
1513
    case 0x23:                  // BLT HEIGHT 0x001f00
 
1514
    case 0x25:                  // BLT DEST PITCH 0x001f00
 
1515
    case 0x27:                  // BLT SRC PITCH 0x001f00
 
1516
        s->vga.gr[reg_index] = reg_value & 0x1f;
 
1517
        break;
 
1518
    case 0x2a:                  // BLT DEST ADDR 0x3f0000
 
1519
        s->vga.gr[reg_index] = reg_value & 0x3f;
 
1520
        /* if auto start mode, starts bit blt now */
 
1521
        if (s->vga.gr[0x31] & CIRRUS_BLT_AUTOSTART) {
 
1522
            cirrus_bitblt_start(s);
 
1523
        }
 
1524
        break;
 
1525
    case 0x2e:                  // BLT SRC ADDR 0x3f0000
 
1526
        s->vga.gr[reg_index] = reg_value & 0x3f;
 
1527
        break;
 
1528
    case 0x31:                  // BLT STATUS/START
 
1529
        cirrus_write_bitblt(s, reg_value);
 
1530
        break;
 
1531
    default:
 
1532
#ifdef DEBUG_CIRRUS
 
1533
        printf("cirrus: outport gr_index %02x, gr_value %02x\n", reg_index,
 
1534
               reg_value);
 
1535
#endif
 
1536
        break;
 
1537
    }
 
1538
}
 
1539
 
 
1540
/***************************************
 
1541
 *
 
1542
 *  I/O access between 0x3d4-0x3d5
 
1543
 *
 
1544
 ***************************************/
 
1545
 
 
1546
static int cirrus_vga_read_cr(CirrusVGAState * s, unsigned reg_index)
 
1547
{
 
1548
    switch (reg_index) {
 
1549
    case 0x00:                  // Standard VGA
 
1550
    case 0x01:                  // Standard VGA
 
1551
    case 0x02:                  // Standard VGA
 
1552
    case 0x03:                  // Standard VGA
 
1553
    case 0x04:                  // Standard VGA
 
1554
    case 0x05:                  // Standard VGA
 
1555
    case 0x06:                  // Standard VGA
 
1556
    case 0x07:                  // Standard VGA
 
1557
    case 0x08:                  // Standard VGA
 
1558
    case 0x09:                  // Standard VGA
 
1559
    case 0x0a:                  // Standard VGA
 
1560
    case 0x0b:                  // Standard VGA
 
1561
    case 0x0c:                  // Standard VGA
 
1562
    case 0x0d:                  // Standard VGA
 
1563
    case 0x0e:                  // Standard VGA
 
1564
    case 0x0f:                  // Standard VGA
 
1565
    case 0x10:                  // Standard VGA
 
1566
    case 0x11:                  // Standard VGA
 
1567
    case 0x12:                  // Standard VGA
 
1568
    case 0x13:                  // Standard VGA
 
1569
    case 0x14:                  // Standard VGA
 
1570
    case 0x15:                  // Standard VGA
 
1571
    case 0x16:                  // Standard VGA
 
1572
    case 0x17:                  // Standard VGA
 
1573
    case 0x18:                  // Standard VGA
 
1574
        return s->vga.cr[s->vga.cr_index];
 
1575
    case 0x24:                  // Attribute Controller Toggle Readback (R)
 
1576
        return (s->vga.ar_flip_flop << 7);
 
1577
    case 0x19:                  // Interlace End
 
1578
    case 0x1a:                  // Miscellaneous Control
 
1579
    case 0x1b:                  // Extended Display Control
 
1580
    case 0x1c:                  // Sync Adjust and Genlock
 
1581
    case 0x1d:                  // Overlay Extended Control
 
1582
    case 0x22:                  // Graphics Data Latches Readback (R)
 
1583
    case 0x25:                  // Part Status
 
1584
    case 0x27:                  // Part ID (R)
 
1585
        return s->vga.cr[s->vga.cr_index];
 
1586
    case 0x26:                  // Attribute Controller Index Readback (R)
 
1587
        return s->vga.ar_index & 0x3f;
 
1588
        break;
 
1589
    default:
 
1590
#ifdef DEBUG_CIRRUS
 
1591
        printf("cirrus: inport cr_index %02x\n", reg_index);
 
1592
#endif
 
1593
        return 0xff;
 
1594
    }
 
1595
}
 
1596
 
 
1597
static void cirrus_vga_write_cr(CirrusVGAState * s, int reg_value)
 
1598
{
 
1599
    switch (s->vga.cr_index) {
 
1600
    case 0x00:                  // Standard VGA
 
1601
    case 0x01:                  // Standard VGA
 
1602
    case 0x02:                  // Standard VGA
 
1603
    case 0x03:                  // Standard VGA
 
1604
    case 0x04:                  // Standard VGA
 
1605
    case 0x05:                  // Standard VGA
 
1606
    case 0x06:                  // Standard VGA
 
1607
    case 0x07:                  // Standard VGA
 
1608
    case 0x08:                  // Standard VGA
 
1609
    case 0x09:                  // Standard VGA
 
1610
    case 0x0a:                  // Standard VGA
 
1611
    case 0x0b:                  // Standard VGA
 
1612
    case 0x0c:                  // Standard VGA
 
1613
    case 0x0d:                  // Standard VGA
 
1614
    case 0x0e:                  // Standard VGA
 
1615
    case 0x0f:                  // Standard VGA
 
1616
    case 0x10:                  // Standard VGA
 
1617
    case 0x11:                  // Standard VGA
 
1618
    case 0x12:                  // Standard VGA
 
1619
    case 0x13:                  // Standard VGA
 
1620
    case 0x14:                  // Standard VGA
 
1621
    case 0x15:                  // Standard VGA
 
1622
    case 0x16:                  // Standard VGA
 
1623
    case 0x17:                  // Standard VGA
 
1624
    case 0x18:                  // Standard VGA
 
1625
        /* handle CR0-7 protection */
 
1626
        if ((s->vga.cr[0x11] & 0x80) && s->vga.cr_index <= 7) {
 
1627
            /* can always write bit 4 of CR7 */
 
1628
            if (s->vga.cr_index == 7)
 
1629
                s->vga.cr[7] = (s->vga.cr[7] & ~0x10) | (reg_value & 0x10);
 
1630
            return;
 
1631
        }
 
1632
        s->vga.cr[s->vga.cr_index] = reg_value;
 
1633
        switch(s->vga.cr_index) {
 
1634
        case 0x00:
 
1635
        case 0x04:
 
1636
        case 0x05:
 
1637
        case 0x06:
 
1638
        case 0x07:
 
1639
        case 0x11:
 
1640
        case 0x17:
 
1641
            s->vga.update_retrace_info(&s->vga);
 
1642
            break;
 
1643
        }
 
1644
        break;
 
1645
    case 0x19:                  // Interlace End
 
1646
    case 0x1a:                  // Miscellaneous Control
 
1647
    case 0x1b:                  // Extended Display Control
 
1648
    case 0x1c:                  // Sync Adjust and Genlock
 
1649
    case 0x1d:                  // Overlay Extended Control
 
1650
        s->vga.cr[s->vga.cr_index] = reg_value;
 
1651
#ifdef DEBUG_CIRRUS
 
1652
        printf("cirrus: handled outport cr_index %02x, cr_value %02x\n",
 
1653
               s->vga.cr_index, reg_value);
 
1654
#endif
 
1655
        break;
 
1656
    case 0x22:                  // Graphics Data Latches Readback (R)
 
1657
    case 0x24:                  // Attribute Controller Toggle Readback (R)
 
1658
    case 0x26:                  // Attribute Controller Index Readback (R)
 
1659
    case 0x27:                  // Part ID (R)
 
1660
        break;
 
1661
    case 0x25:                  // Part Status
 
1662
    default:
 
1663
#ifdef DEBUG_CIRRUS
 
1664
        printf("cirrus: outport cr_index %02x, cr_value %02x\n",
 
1665
               s->vga.cr_index, reg_value);
 
1666
#endif
 
1667
        break;
 
1668
    }
 
1669
}
 
1670
 
 
1671
/***************************************
 
1672
 *
 
1673
 *  memory-mapped I/O (bitblt)
 
1674
 *
 
1675
 ***************************************/
 
1676
 
 
1677
static uint8_t cirrus_mmio_blt_read(CirrusVGAState * s, unsigned address)
 
1678
{
 
1679
    int value = 0xff;
 
1680
 
 
1681
    switch (address) {
 
1682
    case (CIRRUS_MMIO_BLTBGCOLOR + 0):
 
1683
        value = cirrus_vga_read_gr(s, 0x00);
 
1684
        break;
 
1685
    case (CIRRUS_MMIO_BLTBGCOLOR + 1):
 
1686
        value = cirrus_vga_read_gr(s, 0x10);
 
1687
        break;
 
1688
    case (CIRRUS_MMIO_BLTBGCOLOR + 2):
 
1689
        value = cirrus_vga_read_gr(s, 0x12);
 
1690
        break;
 
1691
    case (CIRRUS_MMIO_BLTBGCOLOR + 3):
 
1692
        value = cirrus_vga_read_gr(s, 0x14);
 
1693
        break;
 
1694
    case (CIRRUS_MMIO_BLTFGCOLOR + 0):
 
1695
        value = cirrus_vga_read_gr(s, 0x01);
 
1696
        break;
 
1697
    case (CIRRUS_MMIO_BLTFGCOLOR + 1):
 
1698
        value = cirrus_vga_read_gr(s, 0x11);
 
1699
        break;
 
1700
    case (CIRRUS_MMIO_BLTFGCOLOR + 2):
 
1701
        value = cirrus_vga_read_gr(s, 0x13);
 
1702
        break;
 
1703
    case (CIRRUS_MMIO_BLTFGCOLOR + 3):
 
1704
        value = cirrus_vga_read_gr(s, 0x15);
 
1705
        break;
 
1706
    case (CIRRUS_MMIO_BLTWIDTH + 0):
 
1707
        value = cirrus_vga_read_gr(s, 0x20);
 
1708
        break;
 
1709
    case (CIRRUS_MMIO_BLTWIDTH + 1):
 
1710
        value = cirrus_vga_read_gr(s, 0x21);
 
1711
        break;
 
1712
    case (CIRRUS_MMIO_BLTHEIGHT + 0):
 
1713
        value = cirrus_vga_read_gr(s, 0x22);
 
1714
        break;
 
1715
    case (CIRRUS_MMIO_BLTHEIGHT + 1):
 
1716
        value = cirrus_vga_read_gr(s, 0x23);
 
1717
        break;
 
1718
    case (CIRRUS_MMIO_BLTDESTPITCH + 0):
 
1719
        value = cirrus_vga_read_gr(s, 0x24);
 
1720
        break;
 
1721
    case (CIRRUS_MMIO_BLTDESTPITCH + 1):
 
1722
        value = cirrus_vga_read_gr(s, 0x25);
 
1723
        break;
 
1724
    case (CIRRUS_MMIO_BLTSRCPITCH + 0):
 
1725
        value = cirrus_vga_read_gr(s, 0x26);
 
1726
        break;
 
1727
    case (CIRRUS_MMIO_BLTSRCPITCH + 1):
 
1728
        value = cirrus_vga_read_gr(s, 0x27);
 
1729
        break;
 
1730
    case (CIRRUS_MMIO_BLTDESTADDR + 0):
 
1731
        value = cirrus_vga_read_gr(s, 0x28);
 
1732
        break;
 
1733
    case (CIRRUS_MMIO_BLTDESTADDR + 1):
 
1734
        value = cirrus_vga_read_gr(s, 0x29);
 
1735
        break;
 
1736
    case (CIRRUS_MMIO_BLTDESTADDR + 2):
 
1737
        value = cirrus_vga_read_gr(s, 0x2a);
 
1738
        break;
 
1739
    case (CIRRUS_MMIO_BLTSRCADDR + 0):
 
1740
        value = cirrus_vga_read_gr(s, 0x2c);
 
1741
        break;
 
1742
    case (CIRRUS_MMIO_BLTSRCADDR + 1):
 
1743
        value = cirrus_vga_read_gr(s, 0x2d);
 
1744
        break;
 
1745
    case (CIRRUS_MMIO_BLTSRCADDR + 2):
 
1746
        value = cirrus_vga_read_gr(s, 0x2e);
 
1747
        break;
 
1748
    case CIRRUS_MMIO_BLTWRITEMASK:
 
1749
        value = cirrus_vga_read_gr(s, 0x2f);
 
1750
        break;
 
1751
    case CIRRUS_MMIO_BLTMODE:
 
1752
        value = cirrus_vga_read_gr(s, 0x30);
 
1753
        break;
 
1754
    case CIRRUS_MMIO_BLTROP:
 
1755
        value = cirrus_vga_read_gr(s, 0x32);
 
1756
        break;
 
1757
    case CIRRUS_MMIO_BLTMODEEXT:
 
1758
        value = cirrus_vga_read_gr(s, 0x33);
 
1759
        break;
 
1760
    case (CIRRUS_MMIO_BLTTRANSPARENTCOLOR + 0):
 
1761
        value = cirrus_vga_read_gr(s, 0x34);
 
1762
        break;
 
1763
    case (CIRRUS_MMIO_BLTTRANSPARENTCOLOR + 1):
 
1764
        value = cirrus_vga_read_gr(s, 0x35);
 
1765
        break;
 
1766
    case (CIRRUS_MMIO_BLTTRANSPARENTCOLORMASK + 0):
 
1767
        value = cirrus_vga_read_gr(s, 0x38);
 
1768
        break;
 
1769
    case (CIRRUS_MMIO_BLTTRANSPARENTCOLORMASK + 1):
 
1770
        value = cirrus_vga_read_gr(s, 0x39);
 
1771
        break;
 
1772
    case CIRRUS_MMIO_BLTSTATUS:
 
1773
        value = cirrus_vga_read_gr(s, 0x31);
 
1774
        break;
 
1775
    default:
 
1776
#ifdef DEBUG_CIRRUS
 
1777
        printf("cirrus: mmio read - address 0x%04x\n", address);
 
1778
#endif
 
1779
        break;
 
1780
    }
 
1781
 
 
1782
    return (uint8_t) value;
 
1783
}
 
1784
 
 
1785
static void cirrus_mmio_blt_write(CirrusVGAState * s, unsigned address,
 
1786
                                  uint8_t value)
 
1787
{
 
1788
    switch (address) {
 
1789
    case (CIRRUS_MMIO_BLTBGCOLOR + 0):
 
1790
        cirrus_vga_write_gr(s, 0x00, value);
 
1791
        break;
 
1792
    case (CIRRUS_MMIO_BLTBGCOLOR + 1):
 
1793
        cirrus_vga_write_gr(s, 0x10, value);
 
1794
        break;
 
1795
    case (CIRRUS_MMIO_BLTBGCOLOR + 2):
 
1796
        cirrus_vga_write_gr(s, 0x12, value);
 
1797
        break;
 
1798
    case (CIRRUS_MMIO_BLTBGCOLOR + 3):
 
1799
        cirrus_vga_write_gr(s, 0x14, value);
 
1800
        break;
 
1801
    case (CIRRUS_MMIO_BLTFGCOLOR + 0):
 
1802
        cirrus_vga_write_gr(s, 0x01, value);
 
1803
        break;
 
1804
    case (CIRRUS_MMIO_BLTFGCOLOR + 1):
 
1805
        cirrus_vga_write_gr(s, 0x11, value);
 
1806
        break;
 
1807
    case (CIRRUS_MMIO_BLTFGCOLOR + 2):
 
1808
        cirrus_vga_write_gr(s, 0x13, value);
 
1809
        break;
 
1810
    case (CIRRUS_MMIO_BLTFGCOLOR + 3):
 
1811
        cirrus_vga_write_gr(s, 0x15, value);
 
1812
        break;
 
1813
    case (CIRRUS_MMIO_BLTWIDTH + 0):
 
1814
        cirrus_vga_write_gr(s, 0x20, value);
 
1815
        break;
 
1816
    case (CIRRUS_MMIO_BLTWIDTH + 1):
 
1817
        cirrus_vga_write_gr(s, 0x21, value);
 
1818
        break;
 
1819
    case (CIRRUS_MMIO_BLTHEIGHT + 0):
 
1820
        cirrus_vga_write_gr(s, 0x22, value);
 
1821
        break;
 
1822
    case (CIRRUS_MMIO_BLTHEIGHT + 1):
 
1823
        cirrus_vga_write_gr(s, 0x23, value);
 
1824
        break;
 
1825
    case (CIRRUS_MMIO_BLTDESTPITCH + 0):
 
1826
        cirrus_vga_write_gr(s, 0x24, value);
 
1827
        break;
 
1828
    case (CIRRUS_MMIO_BLTDESTPITCH + 1):
 
1829
        cirrus_vga_write_gr(s, 0x25, value);
 
1830
        break;
 
1831
    case (CIRRUS_MMIO_BLTSRCPITCH + 0):
 
1832
        cirrus_vga_write_gr(s, 0x26, value);
 
1833
        break;
 
1834
    case (CIRRUS_MMIO_BLTSRCPITCH + 1):
 
1835
        cirrus_vga_write_gr(s, 0x27, value);
 
1836
        break;
 
1837
    case (CIRRUS_MMIO_BLTDESTADDR + 0):
 
1838
        cirrus_vga_write_gr(s, 0x28, value);
 
1839
        break;
 
1840
    case (CIRRUS_MMIO_BLTDESTADDR + 1):
 
1841
        cirrus_vga_write_gr(s, 0x29, value);
 
1842
        break;
 
1843
    case (CIRRUS_MMIO_BLTDESTADDR + 2):
 
1844
        cirrus_vga_write_gr(s, 0x2a, value);
 
1845
        break;
 
1846
    case (CIRRUS_MMIO_BLTDESTADDR + 3):
 
1847
        /* ignored */
 
1848
        break;
 
1849
    case (CIRRUS_MMIO_BLTSRCADDR + 0):
 
1850
        cirrus_vga_write_gr(s, 0x2c, value);
 
1851
        break;
 
1852
    case (CIRRUS_MMIO_BLTSRCADDR + 1):
 
1853
        cirrus_vga_write_gr(s, 0x2d, value);
 
1854
        break;
 
1855
    case (CIRRUS_MMIO_BLTSRCADDR + 2):
 
1856
        cirrus_vga_write_gr(s, 0x2e, value);
 
1857
        break;
 
1858
    case CIRRUS_MMIO_BLTWRITEMASK:
 
1859
        cirrus_vga_write_gr(s, 0x2f, value);
 
1860
        break;
 
1861
    case CIRRUS_MMIO_BLTMODE:
 
1862
        cirrus_vga_write_gr(s, 0x30, value);
 
1863
        break;
 
1864
    case CIRRUS_MMIO_BLTROP:
 
1865
        cirrus_vga_write_gr(s, 0x32, value);
 
1866
        break;
 
1867
    case CIRRUS_MMIO_BLTMODEEXT:
 
1868
        cirrus_vga_write_gr(s, 0x33, value);
 
1869
        break;
 
1870
    case (CIRRUS_MMIO_BLTTRANSPARENTCOLOR + 0):
 
1871
        cirrus_vga_write_gr(s, 0x34, value);
 
1872
        break;
 
1873
    case (CIRRUS_MMIO_BLTTRANSPARENTCOLOR + 1):
 
1874
        cirrus_vga_write_gr(s, 0x35, value);
 
1875
        break;
 
1876
    case (CIRRUS_MMIO_BLTTRANSPARENTCOLORMASK + 0):
 
1877
        cirrus_vga_write_gr(s, 0x38, value);
 
1878
        break;
 
1879
    case (CIRRUS_MMIO_BLTTRANSPARENTCOLORMASK + 1):
 
1880
        cirrus_vga_write_gr(s, 0x39, value);
 
1881
        break;
 
1882
    case CIRRUS_MMIO_BLTSTATUS:
 
1883
        cirrus_vga_write_gr(s, 0x31, value);
 
1884
        break;
 
1885
    default:
 
1886
#ifdef DEBUG_CIRRUS
 
1887
        printf("cirrus: mmio write - addr 0x%04x val 0x%02x (ignored)\n",
 
1888
               address, value);
 
1889
#endif
 
1890
        break;
 
1891
    }
 
1892
}
 
1893
 
 
1894
/***************************************
 
1895
 *
 
1896
 *  write mode 4/5
 
1897
 *
 
1898
 * assume TARGET_PAGE_SIZE >= 16
 
1899
 *
 
1900
 ***************************************/
 
1901
 
 
1902
static void cirrus_mem_writeb_mode4and5_8bpp(CirrusVGAState * s,
 
1903
                                             unsigned mode,
 
1904
                                             unsigned offset,
 
1905
                                             uint32_t mem_value)
 
1906
{
 
1907
    int x;
 
1908
    unsigned val = mem_value;
 
1909
    uint8_t *dst;
 
1910
 
 
1911
    dst = s->vga.vram_ptr + (offset &= s->cirrus_addr_mask);
 
1912
    for (x = 0; x < 8; x++) {
 
1913
        if (val & 0x80) {
 
1914
            *dst = s->cirrus_shadow_gr1;
 
1915
        } else if (mode == 5) {
 
1916
            *dst = s->cirrus_shadow_gr0;
 
1917
        }
 
1918
        val <<= 1;
 
1919
        dst++;
 
1920
    }
 
1921
    memory_region_set_dirty(&s->vga.vram, offset);
 
1922
    memory_region_set_dirty(&s->vga.vram, offset + 7);
 
1923
}
 
1924
 
 
1925
static void cirrus_mem_writeb_mode4and5_16bpp(CirrusVGAState * s,
 
1926
                                              unsigned mode,
 
1927
                                              unsigned offset,
 
1928
                                              uint32_t mem_value)
 
1929
{
 
1930
    int x;
 
1931
    unsigned val = mem_value;
 
1932
    uint8_t *dst;
 
1933
 
 
1934
    dst = s->vga.vram_ptr + (offset &= s->cirrus_addr_mask);
 
1935
    for (x = 0; x < 8; x++) {
 
1936
        if (val & 0x80) {
 
1937
            *dst = s->cirrus_shadow_gr1;
 
1938
            *(dst + 1) = s->vga.gr[0x11];
 
1939
        } else if (mode == 5) {
 
1940
            *dst = s->cirrus_shadow_gr0;
 
1941
            *(dst + 1) = s->vga.gr[0x10];
 
1942
        }
 
1943
        val <<= 1;
 
1944
        dst += 2;
 
1945
    }
 
1946
    memory_region_set_dirty(&s->vga.vram, offset);
 
1947
    memory_region_set_dirty(&s->vga.vram, offset + 15);
 
1948
}
 
1949
 
 
1950
/***************************************
 
1951
 *
 
1952
 *  memory access between 0xa0000-0xbffff
 
1953
 *
 
1954
 ***************************************/
 
1955
 
 
1956
static uint64_t cirrus_vga_mem_read(void *opaque,
 
1957
                                    target_phys_addr_t addr,
 
1958
                                    uint32_t size)
 
1959
{
 
1960
    CirrusVGAState *s = opaque;
 
1961
    unsigned bank_index;
 
1962
    unsigned bank_offset;
 
1963
    uint32_t val;
 
1964
 
 
1965
    if ((s->vga.sr[0x07] & 0x01) == 0) {
 
1966
        return vga_mem_readb(&s->vga, addr);
 
1967
    }
 
1968
 
 
1969
    if (addr < 0x10000) {
 
1970
        /* XXX handle bitblt */
 
1971
        /* video memory */
 
1972
        bank_index = addr >> 15;
 
1973
        bank_offset = addr & 0x7fff;
 
1974
        if (bank_offset < s->cirrus_bank_limit[bank_index]) {
 
1975
            bank_offset += s->cirrus_bank_base[bank_index];
 
1976
            if ((s->vga.gr[0x0B] & 0x14) == 0x14) {
 
1977
                bank_offset <<= 4;
 
1978
            } else if (s->vga.gr[0x0B] & 0x02) {
 
1979
                bank_offset <<= 3;
 
1980
            }
 
1981
            bank_offset &= s->cirrus_addr_mask;
 
1982
            val = *(s->vga.vram_ptr + bank_offset);
 
1983
        } else
 
1984
            val = 0xff;
 
1985
    } else if (addr >= 0x18000 && addr < 0x18100) {
 
1986
        /* memory-mapped I/O */
 
1987
        val = 0xff;
 
1988
        if ((s->vga.sr[0x17] & 0x44) == 0x04) {
 
1989
            val = cirrus_mmio_blt_read(s, addr & 0xff);
 
1990
        }
 
1991
    } else {
 
1992
        val = 0xff;
 
1993
#ifdef DEBUG_CIRRUS
 
1994
        printf("cirrus: mem_readb " TARGET_FMT_plx "\n", addr);
 
1995
#endif
 
1996
    }
 
1997
    return val;
 
1998
}
 
1999
 
 
2000
static void cirrus_vga_mem_write(void *opaque,
 
2001
                                 target_phys_addr_t addr,
 
2002
                                 uint64_t mem_value,
 
2003
                                 uint32_t size)
 
2004
{
 
2005
    CirrusVGAState *s = opaque;
 
2006
    unsigned bank_index;
 
2007
    unsigned bank_offset;
 
2008
    unsigned mode;
 
2009
 
 
2010
    if ((s->vga.sr[0x07] & 0x01) == 0) {
 
2011
        vga_mem_writeb(&s->vga, addr, mem_value);
 
2012
        return;
 
2013
    }
 
2014
 
 
2015
    if (addr < 0x10000) {
 
2016
        if (s->cirrus_srcptr != s->cirrus_srcptr_end) {
 
2017
            /* bitblt */
 
2018
            *s->cirrus_srcptr++ = (uint8_t) mem_value;
 
2019
            if (s->cirrus_srcptr >= s->cirrus_srcptr_end) {
 
2020
                cirrus_bitblt_cputovideo_next(s);
 
2021
            }
 
2022
        } else {
 
2023
            /* video memory */
 
2024
            bank_index = addr >> 15;
 
2025
            bank_offset = addr & 0x7fff;
 
2026
            if (bank_offset < s->cirrus_bank_limit[bank_index]) {
 
2027
                bank_offset += s->cirrus_bank_base[bank_index];
 
2028
                if ((s->vga.gr[0x0B] & 0x14) == 0x14) {
 
2029
                    bank_offset <<= 4;
 
2030
                } else if (s->vga.gr[0x0B] & 0x02) {
 
2031
                    bank_offset <<= 3;
 
2032
                }
 
2033
                bank_offset &= s->cirrus_addr_mask;
 
2034
                mode = s->vga.gr[0x05] & 0x7;
 
2035
                if (mode < 4 || mode > 5 || ((s->vga.gr[0x0B] & 0x4) == 0)) {
 
2036
                    *(s->vga.vram_ptr + bank_offset) = mem_value;
 
2037
                    memory_region_set_dirty(&s->vga.vram, bank_offset);
 
2038
                } else {
 
2039
                    if ((s->vga.gr[0x0B] & 0x14) != 0x14) {
 
2040
                        cirrus_mem_writeb_mode4and5_8bpp(s, mode,
 
2041
                                                         bank_offset,
 
2042
                                                         mem_value);
 
2043
                    } else {
 
2044
                        cirrus_mem_writeb_mode4and5_16bpp(s, mode,
 
2045
                                                          bank_offset,
 
2046
                                                          mem_value);
 
2047
                    }
 
2048
                }
 
2049
            }
 
2050
        }
 
2051
    } else if (addr >= 0x18000 && addr < 0x18100) {
 
2052
        /* memory-mapped I/O */
 
2053
        if ((s->vga.sr[0x17] & 0x44) == 0x04) {
 
2054
            cirrus_mmio_blt_write(s, addr & 0xff, mem_value);
 
2055
        }
 
2056
    } else {
 
2057
#ifdef DEBUG_CIRRUS
 
2058
        printf("cirrus: mem_writeb " TARGET_FMT_plx " value %02x\n", addr,
 
2059
               mem_value);
 
2060
#endif
 
2061
    }
 
2062
}
 
2063
 
 
2064
static const MemoryRegionOps cirrus_vga_mem_ops = {
 
2065
    .read = cirrus_vga_mem_read,
 
2066
    .write = cirrus_vga_mem_write,
 
2067
    .endianness = DEVICE_LITTLE_ENDIAN,
 
2068
    .impl = {
 
2069
        .min_access_size = 1,
 
2070
        .max_access_size = 1,
 
2071
    },
 
2072
};
 
2073
 
 
2074
/***************************************
 
2075
 *
 
2076
 *  hardware cursor
 
2077
 *
 
2078
 ***************************************/
 
2079
 
 
2080
static inline void invalidate_cursor1(CirrusVGAState *s)
 
2081
{
 
2082
    if (s->last_hw_cursor_size) {
 
2083
        vga_invalidate_scanlines(&s->vga,
 
2084
                                 s->last_hw_cursor_y + s->last_hw_cursor_y_start,
 
2085
                                 s->last_hw_cursor_y + s->last_hw_cursor_y_end);
 
2086
    }
 
2087
}
 
2088
 
 
2089
static inline void cirrus_cursor_compute_yrange(CirrusVGAState *s)
 
2090
{
 
2091
    const uint8_t *src;
 
2092
    uint32_t content;
 
2093
    int y, y_min, y_max;
 
2094
 
 
2095
    src = s->vga.vram_ptr + s->real_vram_size - 16 * 1024;
 
2096
    if (s->vga.sr[0x12] & CIRRUS_CURSOR_LARGE) {
 
2097
        src += (s->vga.sr[0x13] & 0x3c) * 256;
 
2098
        y_min = 64;
 
2099
        y_max = -1;
 
2100
        for(y = 0; y < 64; y++) {
 
2101
            content = ((uint32_t *)src)[0] |
 
2102
                ((uint32_t *)src)[1] |
 
2103
                ((uint32_t *)src)[2] |
 
2104
                ((uint32_t *)src)[3];
 
2105
            if (content) {
 
2106
                if (y < y_min)
 
2107
                    y_min = y;
 
2108
                if (y > y_max)
 
2109
                    y_max = y;
 
2110
            }
 
2111
            src += 16;
 
2112
        }
 
2113
    } else {
 
2114
        src += (s->vga.sr[0x13] & 0x3f) * 256;
 
2115
        y_min = 32;
 
2116
        y_max = -1;
 
2117
        for(y = 0; y < 32; y++) {
 
2118
            content = ((uint32_t *)src)[0] |
 
2119
                ((uint32_t *)(src + 128))[0];
 
2120
            if (content) {
 
2121
                if (y < y_min)
 
2122
                    y_min = y;
 
2123
                if (y > y_max)
 
2124
                    y_max = y;
 
2125
            }
 
2126
            src += 4;
 
2127
        }
 
2128
    }
 
2129
    if (y_min > y_max) {
 
2130
        s->last_hw_cursor_y_start = 0;
 
2131
        s->last_hw_cursor_y_end = 0;
 
2132
    } else {
 
2133
        s->last_hw_cursor_y_start = y_min;
 
2134
        s->last_hw_cursor_y_end = y_max + 1;
 
2135
    }
 
2136
}
 
2137
 
 
2138
/* NOTE: we do not currently handle the cursor bitmap change, so we
 
2139
   update the cursor only if it moves. */
 
2140
static void cirrus_cursor_invalidate(VGACommonState *s1)
 
2141
{
 
2142
    CirrusVGAState *s = container_of(s1, CirrusVGAState, vga);
 
2143
    int size;
 
2144
 
 
2145
    if (!(s->vga.sr[0x12] & CIRRUS_CURSOR_SHOW)) {
 
2146
        size = 0;
 
2147
    } else {
 
2148
        if (s->vga.sr[0x12] & CIRRUS_CURSOR_LARGE)
 
2149
            size = 64;
 
2150
        else
 
2151
            size = 32;
 
2152
    }
 
2153
    /* invalidate last cursor and new cursor if any change */
 
2154
    if (s->last_hw_cursor_size != size ||
 
2155
        s->last_hw_cursor_x != s->hw_cursor_x ||
 
2156
        s->last_hw_cursor_y != s->hw_cursor_y) {
 
2157
 
 
2158
        invalidate_cursor1(s);
 
2159
 
 
2160
        s->last_hw_cursor_size = size;
 
2161
        s->last_hw_cursor_x = s->hw_cursor_x;
 
2162
        s->last_hw_cursor_y = s->hw_cursor_y;
 
2163
        /* compute the real cursor min and max y */
 
2164
        cirrus_cursor_compute_yrange(s);
 
2165
        invalidate_cursor1(s);
 
2166
    }
 
2167
}
 
2168
 
 
2169
static void cirrus_cursor_draw_line(VGACommonState *s1, uint8_t *d1, int scr_y)
 
2170
{
 
2171
    CirrusVGAState *s = container_of(s1, CirrusVGAState, vga);
 
2172
    int w, h, bpp, x1, x2, poffset;
 
2173
    unsigned int color0, color1;
 
2174
    const uint8_t *palette, *src;
 
2175
    uint32_t content;
 
2176
 
 
2177
    if (!(s->vga.sr[0x12] & CIRRUS_CURSOR_SHOW))
 
2178
        return;
 
2179
    /* fast test to see if the cursor intersects with the scan line */
 
2180
    if (s->vga.sr[0x12] & CIRRUS_CURSOR_LARGE) {
 
2181
        h = 64;
 
2182
    } else {
 
2183
        h = 32;
 
2184
    }
 
2185
    if (scr_y < s->hw_cursor_y ||
 
2186
        scr_y >= (s->hw_cursor_y + h))
 
2187
        return;
 
2188
 
 
2189
    src = s->vga.vram_ptr + s->real_vram_size - 16 * 1024;
 
2190
    if (s->vga.sr[0x12] & CIRRUS_CURSOR_LARGE) {
 
2191
        src += (s->vga.sr[0x13] & 0x3c) * 256;
 
2192
        src += (scr_y - s->hw_cursor_y) * 16;
 
2193
        poffset = 8;
 
2194
        content = ((uint32_t *)src)[0] |
 
2195
            ((uint32_t *)src)[1] |
 
2196
            ((uint32_t *)src)[2] |
 
2197
            ((uint32_t *)src)[3];
 
2198
    } else {
 
2199
        src += (s->vga.sr[0x13] & 0x3f) * 256;
 
2200
        src += (scr_y - s->hw_cursor_y) * 4;
 
2201
        poffset = 128;
 
2202
        content = ((uint32_t *)src)[0] |
 
2203
            ((uint32_t *)(src + 128))[0];
 
2204
    }
 
2205
    /* if nothing to draw, no need to continue */
 
2206
    if (!content)
 
2207
        return;
 
2208
    w = h;
 
2209
 
 
2210
    x1 = s->hw_cursor_x;
 
2211
    if (x1 >= s->vga.last_scr_width)
 
2212
        return;
 
2213
    x2 = s->hw_cursor_x + w;
 
2214
    if (x2 > s->vga.last_scr_width)
 
2215
        x2 = s->vga.last_scr_width;
 
2216
    w = x2 - x1;
 
2217
    palette = s->cirrus_hidden_palette;
 
2218
    color0 = s->vga.rgb_to_pixel(c6_to_8(palette[0x0 * 3]),
 
2219
                                 c6_to_8(palette[0x0 * 3 + 1]),
 
2220
                                 c6_to_8(palette[0x0 * 3 + 2]));
 
2221
    color1 = s->vga.rgb_to_pixel(c6_to_8(palette[0xf * 3]),
 
2222
                                 c6_to_8(palette[0xf * 3 + 1]),
 
2223
                                 c6_to_8(palette[0xf * 3 + 2]));
 
2224
    bpp = ((ds_get_bits_per_pixel(s->vga.ds) + 7) >> 3);
 
2225
    d1 += x1 * bpp;
 
2226
    switch(ds_get_bits_per_pixel(s->vga.ds)) {
 
2227
    default:
 
2228
        break;
 
2229
    case 8:
 
2230
        vga_draw_cursor_line_8(d1, src, poffset, w, color0, color1, 0xff);
 
2231
        break;
 
2232
    case 15:
 
2233
        vga_draw_cursor_line_16(d1, src, poffset, w, color0, color1, 0x7fff);
 
2234
        break;
 
2235
    case 16:
 
2236
        vga_draw_cursor_line_16(d1, src, poffset, w, color0, color1, 0xffff);
 
2237
        break;
 
2238
    case 32:
 
2239
        vga_draw_cursor_line_32(d1, src, poffset, w, color0, color1, 0xffffff);
 
2240
        break;
 
2241
    }
 
2242
}
 
2243
 
 
2244
/***************************************
 
2245
 *
 
2246
 *  LFB memory access
 
2247
 *
 
2248
 ***************************************/
 
2249
 
 
2250
static uint64_t cirrus_linear_read(void *opaque, target_phys_addr_t addr,
 
2251
                                   unsigned size)
 
2252
{
 
2253
    CirrusVGAState *s = opaque;
 
2254
    uint32_t ret;
 
2255
 
 
2256
    addr &= s->cirrus_addr_mask;
 
2257
 
 
2258
    if (((s->vga.sr[0x17] & 0x44) == 0x44) &&
 
2259
        ((addr & s->linear_mmio_mask) == s->linear_mmio_mask)) {
 
2260
        /* memory-mapped I/O */
 
2261
        ret = cirrus_mmio_blt_read(s, addr & 0xff);
 
2262
    } else if (0) {
 
2263
        /* XXX handle bitblt */
 
2264
        ret = 0xff;
 
2265
    } else {
 
2266
        /* video memory */
 
2267
        if ((s->vga.gr[0x0B] & 0x14) == 0x14) {
 
2268
            addr <<= 4;
 
2269
        } else if (s->vga.gr[0x0B] & 0x02) {
 
2270
            addr <<= 3;
 
2271
        }
 
2272
        addr &= s->cirrus_addr_mask;
 
2273
        ret = *(s->vga.vram_ptr + addr);
 
2274
    }
 
2275
 
 
2276
    return ret;
 
2277
}
 
2278
 
 
2279
static void cirrus_linear_write(void *opaque, target_phys_addr_t addr,
 
2280
                                uint64_t val, unsigned size)
 
2281
{
 
2282
    CirrusVGAState *s = opaque;
 
2283
    unsigned mode;
 
2284
 
 
2285
    addr &= s->cirrus_addr_mask;
 
2286
 
 
2287
    if (((s->vga.sr[0x17] & 0x44) == 0x44) &&
 
2288
        ((addr & s->linear_mmio_mask) ==  s->linear_mmio_mask)) {
 
2289
        /* memory-mapped I/O */
 
2290
        cirrus_mmio_blt_write(s, addr & 0xff, val);
 
2291
    } else if (s->cirrus_srcptr != s->cirrus_srcptr_end) {
 
2292
        /* bitblt */
 
2293
        *s->cirrus_srcptr++ = (uint8_t) val;
 
2294
        if (s->cirrus_srcptr >= s->cirrus_srcptr_end) {
 
2295
            cirrus_bitblt_cputovideo_next(s);
 
2296
        }
 
2297
    } else {
 
2298
        /* video memory */
 
2299
        if ((s->vga.gr[0x0B] & 0x14) == 0x14) {
 
2300
            addr <<= 4;
 
2301
        } else if (s->vga.gr[0x0B] & 0x02) {
 
2302
            addr <<= 3;
 
2303
        }
 
2304
        addr &= s->cirrus_addr_mask;
 
2305
 
 
2306
        mode = s->vga.gr[0x05] & 0x7;
 
2307
        if (mode < 4 || mode > 5 || ((s->vga.gr[0x0B] & 0x4) == 0)) {
 
2308
            *(s->vga.vram_ptr + addr) = (uint8_t) val;
 
2309
            memory_region_set_dirty(&s->vga.vram, addr);
 
2310
        } else {
 
2311
            if ((s->vga.gr[0x0B] & 0x14) != 0x14) {
 
2312
                cirrus_mem_writeb_mode4and5_8bpp(s, mode, addr, val);
 
2313
            } else {
 
2314
                cirrus_mem_writeb_mode4and5_16bpp(s, mode, addr, val);
 
2315
            }
 
2316
        }
 
2317
    }
 
2318
}
 
2319
 
 
2320
/***************************************
 
2321
 *
 
2322
 *  system to screen memory access
 
2323
 *
 
2324
 ***************************************/
 
2325
 
 
2326
 
 
2327
static uint64_t cirrus_linear_bitblt_read(void *opaque,
 
2328
                                          target_phys_addr_t addr,
 
2329
                                          unsigned size)
 
2330
{
 
2331
    CirrusVGAState *s = opaque;
 
2332
    uint32_t ret;
 
2333
 
 
2334
    /* XXX handle bitblt */
 
2335
    (void)s;
 
2336
    ret = 0xff;
 
2337
    return ret;
 
2338
}
 
2339
 
 
2340
static void cirrus_linear_bitblt_write(void *opaque,
 
2341
                                       target_phys_addr_t addr,
 
2342
                                       uint64_t val,
 
2343
                                       unsigned size)
 
2344
{
 
2345
    CirrusVGAState *s = opaque;
 
2346
 
 
2347
    if (s->cirrus_srcptr != s->cirrus_srcptr_end) {
 
2348
        /* bitblt */
 
2349
        *s->cirrus_srcptr++ = (uint8_t) val;
 
2350
        if (s->cirrus_srcptr >= s->cirrus_srcptr_end) {
 
2351
            cirrus_bitblt_cputovideo_next(s);
 
2352
        }
 
2353
    }
 
2354
}
 
2355
 
 
2356
static const MemoryRegionOps cirrus_linear_bitblt_io_ops = {
 
2357
    .read = cirrus_linear_bitblt_read,
 
2358
    .write = cirrus_linear_bitblt_write,
 
2359
    .endianness = DEVICE_LITTLE_ENDIAN,
 
2360
    .impl = {
 
2361
        .min_access_size = 1,
 
2362
        .max_access_size = 1,
 
2363
    },
 
2364
};
 
2365
 
 
2366
static void unmap_bank(CirrusVGAState *s, unsigned bank)
 
2367
{
 
2368
    if (s->cirrus_bank[bank]) {
 
2369
        memory_region_del_subregion(&s->low_mem_container,
 
2370
                                    s->cirrus_bank[bank]);
 
2371
        memory_region_destroy(s->cirrus_bank[bank]);
 
2372
        g_free(s->cirrus_bank[bank]);
 
2373
        s->cirrus_bank[bank] = NULL;
 
2374
    }
 
2375
}
 
2376
 
 
2377
static void map_linear_vram_bank(CirrusVGAState *s, unsigned bank)
 
2378
{
 
2379
    MemoryRegion *mr;
 
2380
    static const char *names[] = { "vga.bank0", "vga.bank1" };
 
2381
 
 
2382
    if (!(s->cirrus_srcptr != s->cirrus_srcptr_end)
 
2383
        && !((s->vga.sr[0x07] & 0x01) == 0)
 
2384
        && !((s->vga.gr[0x0B] & 0x14) == 0x14)
 
2385
        && !(s->vga.gr[0x0B] & 0x02)) {
 
2386
 
 
2387
        mr = g_malloc(sizeof(*mr));
 
2388
        memory_region_init_alias(mr, names[bank], &s->vga.vram,
 
2389
                                 s->cirrus_bank_base[bank], 0x8000);
 
2390
        memory_region_add_subregion_overlap(
 
2391
            &s->low_mem_container,
 
2392
            0x8000 * bank,
 
2393
            mr,
 
2394
            1);
 
2395
        unmap_bank(s, bank);
 
2396
        s->cirrus_bank[bank] = mr;
 
2397
    } else {
 
2398
        unmap_bank(s, bank);
 
2399
    }
 
2400
}
 
2401
 
 
2402
static void map_linear_vram(CirrusVGAState *s)
 
2403
{
 
2404
    if (s->bustype == CIRRUS_BUSTYPE_PCI && !s->linear_vram) {
 
2405
        s->linear_vram = true;
 
2406
        memory_region_add_subregion_overlap(&s->pci_bar, 0, &s->vga.vram, 1);
 
2407
    }
 
2408
    map_linear_vram_bank(s, 0);
 
2409
    map_linear_vram_bank(s, 1);
 
2410
}
 
2411
 
 
2412
static void unmap_linear_vram(CirrusVGAState *s)
 
2413
{
 
2414
    if (s->bustype == CIRRUS_BUSTYPE_PCI && s->linear_vram) {
 
2415
        s->linear_vram = false;
 
2416
        memory_region_del_subregion(&s->pci_bar, &s->vga.vram);
 
2417
    }
 
2418
    unmap_bank(s, 0);
 
2419
    unmap_bank(s, 1);
 
2420
}
 
2421
 
 
2422
/* Compute the memory access functions */
 
2423
static void cirrus_update_memory_access(CirrusVGAState *s)
 
2424
{
 
2425
    unsigned mode;
 
2426
 
 
2427
    memory_region_transaction_begin();
 
2428
    if ((s->vga.sr[0x17] & 0x44) == 0x44) {
 
2429
        goto generic_io;
 
2430
    } else if (s->cirrus_srcptr != s->cirrus_srcptr_end) {
 
2431
        goto generic_io;
 
2432
    } else {
 
2433
        if ((s->vga.gr[0x0B] & 0x14) == 0x14) {
 
2434
            goto generic_io;
 
2435
        } else if (s->vga.gr[0x0B] & 0x02) {
 
2436
            goto generic_io;
 
2437
        }
 
2438
 
 
2439
        mode = s->vga.gr[0x05] & 0x7;
 
2440
        if (mode < 4 || mode > 5 || ((s->vga.gr[0x0B] & 0x4) == 0)) {
 
2441
            map_linear_vram(s);
 
2442
        } else {
 
2443
        generic_io:
 
2444
            unmap_linear_vram(s);
 
2445
        }
 
2446
    }
 
2447
    memory_region_transaction_commit();
 
2448
}
 
2449
 
 
2450
 
 
2451
/* I/O ports */
 
2452
 
 
2453
static uint32_t cirrus_vga_ioport_read(void *opaque, uint32_t addr)
 
2454
{
 
2455
    CirrusVGAState *c = opaque;
 
2456
    VGACommonState *s = &c->vga;
 
2457
    int val, index;
 
2458
 
 
2459
    if (vga_ioport_invalid(s, addr)) {
 
2460
        val = 0xff;
 
2461
    } else {
 
2462
        switch (addr) {
 
2463
        case 0x3c0:
 
2464
            if (s->ar_flip_flop == 0) {
 
2465
                val = s->ar_index;
 
2466
            } else {
 
2467
                val = 0;
 
2468
            }
 
2469
            break;
 
2470
        case 0x3c1:
 
2471
            index = s->ar_index & 0x1f;
 
2472
            if (index < 21)
 
2473
                val = s->ar[index];
 
2474
            else
 
2475
                val = 0;
 
2476
            break;
 
2477
        case 0x3c2:
 
2478
            val = s->st00;
 
2479
            break;
 
2480
        case 0x3c4:
 
2481
            val = s->sr_index;
 
2482
            break;
 
2483
        case 0x3c5:
 
2484
            val = cirrus_vga_read_sr(c);
 
2485
            break;
 
2486
#ifdef DEBUG_VGA_REG
 
2487
            printf("vga: read SR%x = 0x%02x\n", s->sr_index, val);
 
2488
#endif
 
2489
            break;
 
2490
        case 0x3c6:
 
2491
            val = cirrus_read_hidden_dac(c);
 
2492
            break;
 
2493
        case 0x3c7:
 
2494
            val = s->dac_state;
 
2495
            break;
 
2496
        case 0x3c8:
 
2497
            val = s->dac_write_index;
 
2498
            c->cirrus_hidden_dac_lockindex = 0;
 
2499
            break;
 
2500
        case 0x3c9:
 
2501
            val = cirrus_vga_read_palette(c);
 
2502
            break;
 
2503
        case 0x3ca:
 
2504
            val = s->fcr;
 
2505
            break;
 
2506
        case 0x3cc:
 
2507
            val = s->msr;
 
2508
            break;
 
2509
        case 0x3ce:
 
2510
            val = s->gr_index;
 
2511
            break;
 
2512
        case 0x3cf:
 
2513
            val = cirrus_vga_read_gr(c, s->gr_index);
 
2514
#ifdef DEBUG_VGA_REG
 
2515
            printf("vga: read GR%x = 0x%02x\n", s->gr_index, val);
 
2516
#endif
 
2517
            break;
 
2518
        case 0x3b4:
 
2519
        case 0x3d4:
 
2520
            val = s->cr_index;
 
2521
            break;
 
2522
        case 0x3b5:
 
2523
        case 0x3d5:
 
2524
            val = cirrus_vga_read_cr(c, s->cr_index);
 
2525
#ifdef DEBUG_VGA_REG
 
2526
            printf("vga: read CR%x = 0x%02x\n", s->cr_index, val);
 
2527
#endif
 
2528
            break;
 
2529
        case 0x3ba:
 
2530
        case 0x3da:
 
2531
            /* just toggle to fool polling */
 
2532
            val = s->st01 = s->retrace(s);
 
2533
            s->ar_flip_flop = 0;
 
2534
            break;
 
2535
        default:
 
2536
            val = 0x00;
 
2537
            break;
 
2538
        }
 
2539
    }
 
2540
#if defined(DEBUG_VGA)
 
2541
    printf("VGA: read addr=0x%04x data=0x%02x\n", addr, val);
 
2542
#endif
 
2543
    return val;
 
2544
}
 
2545
 
 
2546
static void cirrus_vga_ioport_write(void *opaque, uint32_t addr, uint32_t val)
 
2547
{
 
2548
    CirrusVGAState *c = opaque;
 
2549
    VGACommonState *s = &c->vga;
 
2550
    int index;
 
2551
 
 
2552
    /* check port range access depending on color/monochrome mode */
 
2553
    if (vga_ioport_invalid(s, addr)) {
 
2554
        return;
 
2555
    }
 
2556
#ifdef DEBUG_VGA
 
2557
    printf("VGA: write addr=0x%04x data=0x%02x\n", addr, val);
 
2558
#endif
 
2559
 
 
2560
    switch (addr) {
 
2561
    case 0x3c0:
 
2562
        if (s->ar_flip_flop == 0) {
 
2563
            val &= 0x3f;
 
2564
            s->ar_index = val;
 
2565
        } else {
 
2566
            index = s->ar_index & 0x1f;
 
2567
            switch (index) {
 
2568
            case 0x00 ... 0x0f:
 
2569
                s->ar[index] = val & 0x3f;
 
2570
                break;
 
2571
            case 0x10:
 
2572
                s->ar[index] = val & ~0x10;
 
2573
                break;
 
2574
            case 0x11:
 
2575
                s->ar[index] = val;
 
2576
                break;
 
2577
            case 0x12:
 
2578
                s->ar[index] = val & ~0xc0;
 
2579
                break;
 
2580
            case 0x13:
 
2581
                s->ar[index] = val & ~0xf0;
 
2582
                break;
 
2583
            case 0x14:
 
2584
                s->ar[index] = val & ~0xf0;
 
2585
                break;
 
2586
            default:
 
2587
                break;
 
2588
            }
 
2589
        }
 
2590
        s->ar_flip_flop ^= 1;
 
2591
        break;
 
2592
    case 0x3c2:
 
2593
        s->msr = val & ~0x10;
 
2594
        s->update_retrace_info(s);
 
2595
        break;
 
2596
    case 0x3c4:
 
2597
        s->sr_index = val;
 
2598
        break;
 
2599
    case 0x3c5:
 
2600
#ifdef DEBUG_VGA_REG
 
2601
        printf("vga: write SR%x = 0x%02x\n", s->sr_index, val);
 
2602
#endif
 
2603
        cirrus_vga_write_sr(c, val);
 
2604
        break;
 
2605
        break;
 
2606
    case 0x3c6:
 
2607
        cirrus_write_hidden_dac(c, val);
 
2608
        break;
 
2609
    case 0x3c7:
 
2610
        s->dac_read_index = val;
 
2611
        s->dac_sub_index = 0;
 
2612
        s->dac_state = 3;
 
2613
        break;
 
2614
    case 0x3c8:
 
2615
        s->dac_write_index = val;
 
2616
        s->dac_sub_index = 0;
 
2617
        s->dac_state = 0;
 
2618
        break;
 
2619
    case 0x3c9:
 
2620
        cirrus_vga_write_palette(c, val);
 
2621
        break;
 
2622
    case 0x3ce:
 
2623
        s->gr_index = val;
 
2624
        break;
 
2625
    case 0x3cf:
 
2626
#ifdef DEBUG_VGA_REG
 
2627
        printf("vga: write GR%x = 0x%02x\n", s->gr_index, val);
 
2628
#endif
 
2629
        cirrus_vga_write_gr(c, s->gr_index, val);
 
2630
        break;
 
2631
    case 0x3b4:
 
2632
    case 0x3d4:
 
2633
        s->cr_index = val;
 
2634
        break;
 
2635
    case 0x3b5:
 
2636
    case 0x3d5:
 
2637
#ifdef DEBUG_VGA_REG
 
2638
        printf("vga: write CR%x = 0x%02x\n", s->cr_index, val);
 
2639
#endif
 
2640
        cirrus_vga_write_cr(c, val);
 
2641
        break;
 
2642
    case 0x3ba:
 
2643
    case 0x3da:
 
2644
        s->fcr = val & 0x10;
 
2645
        break;
 
2646
    }
 
2647
}
 
2648
 
 
2649
/***************************************
 
2650
 *
 
2651
 *  memory-mapped I/O access
 
2652
 *
 
2653
 ***************************************/
 
2654
 
 
2655
static uint64_t cirrus_mmio_read(void *opaque, target_phys_addr_t addr,
 
2656
                                 unsigned size)
 
2657
{
 
2658
    CirrusVGAState *s = opaque;
 
2659
 
 
2660
    if (addr >= 0x100) {
 
2661
        return cirrus_mmio_blt_read(s, addr - 0x100);
 
2662
    } else {
 
2663
        return cirrus_vga_ioport_read(s, addr + 0x3c0);
 
2664
    }
 
2665
}
 
2666
 
 
2667
static void cirrus_mmio_write(void *opaque, target_phys_addr_t addr,
 
2668
                              uint64_t val, unsigned size)
 
2669
{
 
2670
    CirrusVGAState *s = opaque;
 
2671
 
 
2672
    if (addr >= 0x100) {
 
2673
        cirrus_mmio_blt_write(s, addr - 0x100, val);
 
2674
    } else {
 
2675
        cirrus_vga_ioport_write(s, addr + 0x3c0, val);
 
2676
    }
 
2677
}
 
2678
 
 
2679
static const MemoryRegionOps cirrus_mmio_io_ops = {
 
2680
    .read = cirrus_mmio_read,
 
2681
    .write = cirrus_mmio_write,
 
2682
    .endianness = DEVICE_LITTLE_ENDIAN,
 
2683
    .impl = {
 
2684
        .min_access_size = 1,
 
2685
        .max_access_size = 1,
 
2686
    },
 
2687
};
 
2688
 
 
2689
/* load/save state */
 
2690
 
 
2691
static int cirrus_post_load(void *opaque, int version_id)
 
2692
{
 
2693
    CirrusVGAState *s = opaque;
 
2694
 
 
2695
    s->vga.gr[0x00] = s->cirrus_shadow_gr0 & 0x0f;
 
2696
    s->vga.gr[0x01] = s->cirrus_shadow_gr1 & 0x0f;
 
2697
 
 
2698
    cirrus_update_memory_access(s);
 
2699
    /* force refresh */
 
2700
    s->vga.graphic_mode = -1;
 
2701
    cirrus_update_bank_ptr(s, 0);
 
2702
    cirrus_update_bank_ptr(s, 1);
 
2703
    return 0;
 
2704
}
 
2705
 
 
2706
static const VMStateDescription vmstate_cirrus_vga = {
 
2707
    .name = "cirrus_vga",
 
2708
    .version_id = 2,
 
2709
    .minimum_version_id = 1,
 
2710
    .minimum_version_id_old = 1,
 
2711
    .post_load = cirrus_post_load,
 
2712
    .fields      = (VMStateField []) {
 
2713
        VMSTATE_UINT32(vga.latch, CirrusVGAState),
 
2714
        VMSTATE_UINT8(vga.sr_index, CirrusVGAState),
 
2715
        VMSTATE_BUFFER(vga.sr, CirrusVGAState),
 
2716
        VMSTATE_UINT8(vga.gr_index, CirrusVGAState),
 
2717
        VMSTATE_UINT8(cirrus_shadow_gr0, CirrusVGAState),
 
2718
        VMSTATE_UINT8(cirrus_shadow_gr1, CirrusVGAState),
 
2719
        VMSTATE_BUFFER_START_MIDDLE(vga.gr, CirrusVGAState, 2),
 
2720
        VMSTATE_UINT8(vga.ar_index, CirrusVGAState),
 
2721
        VMSTATE_BUFFER(vga.ar, CirrusVGAState),
 
2722
        VMSTATE_INT32(vga.ar_flip_flop, CirrusVGAState),
 
2723
        VMSTATE_UINT8(vga.cr_index, CirrusVGAState),
 
2724
        VMSTATE_BUFFER(vga.cr, CirrusVGAState),
 
2725
        VMSTATE_UINT8(vga.msr, CirrusVGAState),
 
2726
        VMSTATE_UINT8(vga.fcr, CirrusVGAState),
 
2727
        VMSTATE_UINT8(vga.st00, CirrusVGAState),
 
2728
        VMSTATE_UINT8(vga.st01, CirrusVGAState),
 
2729
        VMSTATE_UINT8(vga.dac_state, CirrusVGAState),
 
2730
        VMSTATE_UINT8(vga.dac_sub_index, CirrusVGAState),
 
2731
        VMSTATE_UINT8(vga.dac_read_index, CirrusVGAState),
 
2732
        VMSTATE_UINT8(vga.dac_write_index, CirrusVGAState),
 
2733
        VMSTATE_BUFFER(vga.dac_cache, CirrusVGAState),
 
2734
        VMSTATE_BUFFER(vga.palette, CirrusVGAState),
 
2735
        VMSTATE_INT32(vga.bank_offset, CirrusVGAState),
 
2736
        VMSTATE_UINT8(cirrus_hidden_dac_lockindex, CirrusVGAState),
 
2737
        VMSTATE_UINT8(cirrus_hidden_dac_data, CirrusVGAState),
 
2738
        VMSTATE_UINT32(hw_cursor_x, CirrusVGAState),
 
2739
        VMSTATE_UINT32(hw_cursor_y, CirrusVGAState),
 
2740
        /* XXX: we do not save the bitblt state - we assume we do not save
 
2741
           the state when the blitter is active */
 
2742
        VMSTATE_END_OF_LIST()
 
2743
    }
 
2744
};
 
2745
 
 
2746
static const VMStateDescription vmstate_pci_cirrus_vga = {
 
2747
    .name = "cirrus_vga",
 
2748
    .version_id = 2,
 
2749
    .minimum_version_id = 2,
 
2750
    .minimum_version_id_old = 2,
 
2751
    .fields      = (VMStateField []) {
 
2752
        VMSTATE_PCI_DEVICE(dev, PCICirrusVGAState),
 
2753
        VMSTATE_STRUCT(cirrus_vga, PCICirrusVGAState, 0,
 
2754
                       vmstate_cirrus_vga, CirrusVGAState),
 
2755
        VMSTATE_END_OF_LIST()
 
2756
    }
 
2757
};
 
2758
 
 
2759
/***************************************
 
2760
 *
 
2761
 *  initialize
 
2762
 *
 
2763
 ***************************************/
 
2764
 
 
2765
static void cirrus_reset(void *opaque)
 
2766
{
 
2767
    CirrusVGAState *s = opaque;
 
2768
 
 
2769
    vga_common_reset(&s->vga);
 
2770
    unmap_linear_vram(s);
 
2771
    s->vga.sr[0x06] = 0x0f;
 
2772
    if (s->device_id == CIRRUS_ID_CLGD5446) {
 
2773
        /* 4MB 64 bit memory config, always PCI */
 
2774
        s->vga.sr[0x1F] = 0x2d;         // MemClock
 
2775
        s->vga.gr[0x18] = 0x0f;             // fastest memory configuration
 
2776
        s->vga.sr[0x0f] = 0x98;
 
2777
        s->vga.sr[0x17] = 0x20;
 
2778
        s->vga.sr[0x15] = 0x04; /* memory size, 3=2MB, 4=4MB */
 
2779
    } else {
 
2780
        s->vga.sr[0x1F] = 0x22;         // MemClock
 
2781
        s->vga.sr[0x0F] = CIRRUS_MEMSIZE_2M;
 
2782
        s->vga.sr[0x17] = s->bustype;
 
2783
        s->vga.sr[0x15] = 0x03; /* memory size, 3=2MB, 4=4MB */
 
2784
    }
 
2785
    s->vga.cr[0x27] = s->device_id;
 
2786
 
 
2787
    /* Win2K seems to assume that the pattern buffer is at 0xff
 
2788
       initially ! */
 
2789
    memset(s->vga.vram_ptr, 0xff, s->real_vram_size);
 
2790
 
 
2791
    s->cirrus_hidden_dac_lockindex = 5;
 
2792
    s->cirrus_hidden_dac_data = 0;
 
2793
}
 
2794
 
 
2795
static const MemoryRegionOps cirrus_linear_io_ops = {
 
2796
    .read = cirrus_linear_read,
 
2797
    .write = cirrus_linear_write,
 
2798
    .endianness = DEVICE_LITTLE_ENDIAN,
 
2799
    .impl = {
 
2800
        .min_access_size = 1,
 
2801
        .max_access_size = 1,
 
2802
    },
 
2803
};
 
2804
 
 
2805
static void cirrus_init_common(CirrusVGAState * s, int device_id, int is_pci,
 
2806
                               MemoryRegion *system_memory)
 
2807
{
 
2808
    int i;
 
2809
    static int inited;
 
2810
 
 
2811
    if (!inited) {
 
2812
        inited = 1;
 
2813
        for(i = 0;i < 256; i++)
 
2814
            rop_to_index[i] = CIRRUS_ROP_NOP_INDEX; /* nop rop */
 
2815
        rop_to_index[CIRRUS_ROP_0] = 0;
 
2816
        rop_to_index[CIRRUS_ROP_SRC_AND_DST] = 1;
 
2817
        rop_to_index[CIRRUS_ROP_NOP] = 2;
 
2818
        rop_to_index[CIRRUS_ROP_SRC_AND_NOTDST] = 3;
 
2819
        rop_to_index[CIRRUS_ROP_NOTDST] = 4;
 
2820
        rop_to_index[CIRRUS_ROP_SRC] = 5;
 
2821
        rop_to_index[CIRRUS_ROP_1] = 6;
 
2822
        rop_to_index[CIRRUS_ROP_NOTSRC_AND_DST] = 7;
 
2823
        rop_to_index[CIRRUS_ROP_SRC_XOR_DST] = 8;
 
2824
        rop_to_index[CIRRUS_ROP_SRC_OR_DST] = 9;
 
2825
        rop_to_index[CIRRUS_ROP_NOTSRC_OR_NOTDST] = 10;
 
2826
        rop_to_index[CIRRUS_ROP_SRC_NOTXOR_DST] = 11;
 
2827
        rop_to_index[CIRRUS_ROP_SRC_OR_NOTDST] = 12;
 
2828
        rop_to_index[CIRRUS_ROP_NOTSRC] = 13;
 
2829
        rop_to_index[CIRRUS_ROP_NOTSRC_OR_DST] = 14;
 
2830
        rop_to_index[CIRRUS_ROP_NOTSRC_AND_NOTDST] = 15;
 
2831
        s->device_id = device_id;
 
2832
        if (is_pci)
 
2833
            s->bustype = CIRRUS_BUSTYPE_PCI;
 
2834
        else
 
2835
            s->bustype = CIRRUS_BUSTYPE_ISA;
 
2836
    }
 
2837
 
 
2838
    register_ioport_write(0x3c0, 16, 1, cirrus_vga_ioport_write, s);
 
2839
 
 
2840
    register_ioport_write(0x3b4, 2, 1, cirrus_vga_ioport_write, s);
 
2841
    register_ioport_write(0x3d4, 2, 1, cirrus_vga_ioport_write, s);
 
2842
    register_ioport_write(0x3ba, 1, 1, cirrus_vga_ioport_write, s);
 
2843
    register_ioport_write(0x3da, 1, 1, cirrus_vga_ioport_write, s);
 
2844
 
 
2845
    register_ioport_read(0x3c0, 16, 1, cirrus_vga_ioport_read, s);
 
2846
 
 
2847
    register_ioport_read(0x3b4, 2, 1, cirrus_vga_ioport_read, s);
 
2848
    register_ioport_read(0x3d4, 2, 1, cirrus_vga_ioport_read, s);
 
2849
    register_ioport_read(0x3ba, 1, 1, cirrus_vga_ioport_read, s);
 
2850
    register_ioport_read(0x3da, 1, 1, cirrus_vga_ioport_read, s);
 
2851
 
 
2852
    memory_region_init(&s->low_mem_container,
 
2853
                       "cirrus-lowmem-container",
 
2854
                       0x20000);
 
2855
 
 
2856
    memory_region_init_io(&s->low_mem, &cirrus_vga_mem_ops, s,
 
2857
                          "cirrus-low-memory", 0x20000);
 
2858
    memory_region_add_subregion(&s->low_mem_container, 0, &s->low_mem);
 
2859
    memory_region_add_subregion_overlap(system_memory,
 
2860
                                        isa_mem_base + 0x000a0000,
 
2861
                                        &s->low_mem_container,
 
2862
                                        1);
 
2863
    memory_region_set_coalescing(&s->low_mem);
 
2864
 
 
2865
    /* I/O handler for LFB */
 
2866
    memory_region_init_io(&s->cirrus_linear_io, &cirrus_linear_io_ops, s,
 
2867
                          "cirrus-linear-io", VGA_RAM_SIZE);
 
2868
 
 
2869
    /* I/O handler for LFB */
 
2870
    memory_region_init_io(&s->cirrus_linear_bitblt_io,
 
2871
                          &cirrus_linear_bitblt_io_ops,
 
2872
                          s,
 
2873
                          "cirrus-bitblt-mmio",
 
2874
                          0x400000);
 
2875
 
 
2876
    /* I/O handler for memory-mapped I/O */
 
2877
    memory_region_init_io(&s->cirrus_mmio_io, &cirrus_mmio_io_ops, s,
 
2878
                          "cirrus-mmio", CIRRUS_PNPMMIO_SIZE);
 
2879
 
 
2880
    s->real_vram_size =
 
2881
        (s->device_id == CIRRUS_ID_CLGD5446) ? 4096 * 1024 : 2048 * 1024;
 
2882
 
 
2883
    /* XXX: s->vga.vram_size must be a power of two */
 
2884
    s->cirrus_addr_mask = s->real_vram_size - 1;
 
2885
    s->linear_mmio_mask = s->real_vram_size - 256;
 
2886
 
 
2887
    s->vga.get_bpp = cirrus_get_bpp;
 
2888
    s->vga.get_offsets = cirrus_get_offsets;
 
2889
    s->vga.get_resolution = cirrus_get_resolution;
 
2890
    s->vga.cursor_invalidate = cirrus_cursor_invalidate;
 
2891
    s->vga.cursor_draw_line = cirrus_cursor_draw_line;
 
2892
 
 
2893
    qemu_register_reset(cirrus_reset, s);
 
2894
}
 
2895
 
 
2896
/***************************************
 
2897
 *
 
2898
 *  ISA bus support
 
2899
 *
 
2900
 ***************************************/
 
2901
 
 
2902
void isa_cirrus_vga_init(MemoryRegion *system_memory)
 
2903
{
 
2904
    CirrusVGAState *s;
 
2905
 
 
2906
    s = g_malloc0(sizeof(CirrusVGAState));
 
2907
 
 
2908
    vga_common_init(&s->vga, VGA_RAM_SIZE);
 
2909
    cirrus_init_common(s, CIRRUS_ID_CLGD5430, 0, system_memory);
 
2910
    s->vga.ds = graphic_console_init(s->vga.update, s->vga.invalidate,
 
2911
                                     s->vga.screen_dump, s->vga.text_update,
 
2912
                                     &s->vga);
 
2913
    vmstate_register(NULL, 0, &vmstate_cirrus_vga, s);
 
2914
    rom_add_vga(VGABIOS_CIRRUS_FILENAME);
 
2915
    /* XXX ISA-LFB support */
 
2916
}
 
2917
 
 
2918
/***************************************
 
2919
 *
 
2920
 *  PCI bus support
 
2921
 *
 
2922
 ***************************************/
 
2923
 
 
2924
static int pci_cirrus_vga_initfn(PCIDevice *dev)
 
2925
{
 
2926
     PCICirrusVGAState *d = DO_UPCAST(PCICirrusVGAState, dev, dev);
 
2927
     CirrusVGAState *s = &d->cirrus_vga;
 
2928
     PCIDeviceInfo *info = DO_UPCAST(PCIDeviceInfo, qdev, dev->qdev.info);
 
2929
     int16_t device_id = info->device_id;
 
2930
 
 
2931
     /* setup VGA */
 
2932
     vga_common_init(&s->vga, VGA_RAM_SIZE);
 
2933
     cirrus_init_common(s, device_id, 1, pci_address_space(dev));
 
2934
     s->vga.ds = graphic_console_init(s->vga.update, s->vga.invalidate,
 
2935
                                      s->vga.screen_dump, s->vga.text_update,
 
2936
                                      &s->vga);
 
2937
 
 
2938
     /* setup PCI */
 
2939
 
 
2940
    memory_region_init(&s->pci_bar, "cirrus-pci-bar0", 0x2000000);
 
2941
 
 
2942
    /* XXX: add byte swapping apertures */
 
2943
    memory_region_add_subregion(&s->pci_bar, 0, &s->cirrus_linear_io);
 
2944
    memory_region_add_subregion(&s->pci_bar, 0x1000000,
 
2945
                                &s->cirrus_linear_bitblt_io);
 
2946
 
 
2947
     /* setup memory space */
 
2948
     /* memory #0 LFB */
 
2949
     /* memory #1 memory-mapped I/O */
 
2950
     /* XXX: s->vga.vram_size must be a power of two */
 
2951
     pci_register_bar(&d->dev, 0, PCI_BASE_ADDRESS_MEM_PREFETCH, &s->pci_bar);
 
2952
     if (device_id == CIRRUS_ID_CLGD5446) {
 
2953
         pci_register_bar(&d->dev, 1, 0, &s->cirrus_mmio_io);
 
2954
     }
 
2955
     return 0;
 
2956
}
 
2957
 
 
2958
void pci_cirrus_vga_init(PCIBus *bus)
 
2959
{
 
2960
    pci_create_simple(bus, -1, "cirrus-vga");
 
2961
}
 
2962
 
 
2963
static PCIDeviceInfo cirrus_vga_info = {
 
2964
    .qdev.name    = "cirrus-vga",
 
2965
    .qdev.desc    = "Cirrus CLGD 54xx VGA",
 
2966
    .qdev.size    = sizeof(PCICirrusVGAState),
 
2967
    .qdev.vmsd    = &vmstate_pci_cirrus_vga,
 
2968
    .no_hotplug   = 1,
 
2969
    .init         = pci_cirrus_vga_initfn,
 
2970
    .romfile      = VGABIOS_CIRRUS_FILENAME,
 
2971
    .vendor_id    = PCI_VENDOR_ID_CIRRUS,
 
2972
    .device_id    = CIRRUS_ID_CLGD5446,
 
2973
    .class_id     = PCI_CLASS_DISPLAY_VGA,
 
2974
};
 
2975
 
 
2976
static void cirrus_vga_register(void)
 
2977
{
 
2978
    pci_qdev_register(&cirrus_vga_info);
 
2979
}
 
2980
device_init(cirrus_vga_register);