Palacios Public Git Repository

To checkout Palacios execute

  git clone http://v3vee.org/palacios/palacios.web/palacios.git
This will give you the master branch. You probably want the devel branch or one of the release branches. To switch to the devel branch, simply execute
  cd palacios
  git checkout --track -b devel origin/devel
The other branches are similar.


More detailed error handling on msr writes
[palacios.git] / palacios / src / devices / cga.c
1 /* 
2  * This file is part of the Palacios Virtual Machine Monitor developed
3  * by the V3VEE Project with funding from the United States National 
4  * Science Foundation and the Department of Energy.  
5  *
6  * The V3VEE Project is a joint project between Northwestern University
7  * and the University of New Mexico.  You can find out more at 
8  * http://www.v3vee.org
9  *
10  * Copyright (c) 2009, Robert Deloatch <rtdeloatch@gmail.com>
11  * Copyright (c) 2009, Steven Jaconette <stevenjaconette2007@u.northwestern.edu> 
12  * Copyright (c) 2009, The V3VEE Project <http://www.v3vee.org> 
13  * All rights reserved.
14  *
15  * Author: Robdert Deloatch <rtdeloatch@gmail.com>
16  *         Steven Jaconette <stevenjaconette2007@u.northwestern.edu>
17  *
18  * Initial VGA support added by Erik van der Kouwe <vdkouwe@cs.vu.nl>
19  *
20  * This is free software.  You are permitted to use,
21  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
22  */
23
24 #include <palacios/vmm.h>
25 #include <palacios/vmm_dev_mgr.h>
26 #include <palacios/vmm_emulator.h>
27 #include <palacios/vm_guest_mem.h>
28 #include <palacios/vmm_io.h>
29 #include <palacios/vmm_sprintf.h>
30
31 #include <devices/console.h>
32
33
34 #if V3_CONFIG_DEBUG_CGA >= 2
35 #define PrintVerbose PrintDebug
36 #else
37 #define PrintVerbose(fmt, args...)
38 #endif
39 #if V3_CONFIG_DEBUG_CGA == 0
40 #undef PrintDebug
41 #define PrintDebug(fmt, args...)
42 #endif
43
44
45 #define START_ADDR 0xA0000
46 #define END_ADDR 0xC0000
47
48 #define FRAMEBUF_SIZE (END_ADDR - START_ADDR)
49
50 #define BYTES_PER_COL 2
51
52 struct misc_outp_reg {
53     uint8_t ios         : 1;
54     uint8_t eram        : 1;
55     uint8_t cs          : 1;
56     uint8_t reserved    : 2;
57     uint8_t vsp         : 1;
58     uint8_t hsp         : 1;
59 };
60
61 struct seq_data_reg_clocking_mode {
62     uint8_t d89         : 1;
63     uint8_t reserved1   : 1;
64     uint8_t sl          : 1;
65     uint8_t dc          : 1;
66     uint8_t sh4         : 1;
67     uint8_t so          : 1;
68     uint8_t reserved2   : 2;
69 };
70
71 struct crtc_data_reg_overflow {
72     uint8_t vt8         : 1;
73     uint8_t vde8        : 1;
74     uint8_t vrs8        : 1;
75     uint8_t vbs8        : 1;
76     uint8_t lc8         : 1;
77     uint8_t vt9         : 1;
78     uint8_t vde9        : 1;
79     uint8_t vrs9        : 1;
80 };
81
82 struct crtc_data_reg_max_scan_line {
83     uint8_t msl         : 5;
84     uint8_t vbs9        : 1;
85     uint8_t lc9         : 1;
86     uint8_t dsc         : 1;
87 };
88
89 struct graphc_data_reg_graphics_mode {
90     uint8_t wm          : 2;
91     uint8_t reserved1   : 1;
92     uint8_t rm          : 1;
93     uint8_t or          : 1;
94     uint8_t sr          : 1;
95     uint8_t c256        : 1;
96     uint8_t reserved2   : 1;
97 };
98
99 struct graphc_data_reg_misc {
100     uint8_t gm          : 1;
101     uint8_t oe          : 1;
102     uint8_t mm          : 2;
103     uint8_t reserved    : 4;
104 };
105
106 struct attrc_data_reg_attr_mode_control {
107     uint8_t g           : 1;
108     uint8_t me          : 1;
109     uint8_t elg         : 1;
110     uint8_t eb          : 1;
111     uint8_t reserved    : 1;
112     uint8_t pp          : 1;
113     uint8_t pw          : 1;
114     uint8_t ps          : 1;
115 };
116
117 #define SEQ_REG_COUNT                           5
118 #define SEQ_REGIDX_RESET                        0
119 #define SEQ_REGIDX_CLOCKING_MODE                1
120 #define SEQ_REGIDX_MAP_MASK                     2
121 #define SEQ_REGIDX_CHARACTER_MAP_SELECT         3
122 #define SEQ_REGIDX_MEMORY_MODE                  4
123
124 #define CRTC_REG_COUNT                          25
125 #define CRTC_REGIDX_HORI_TOTAL                  0
126 #define CRTC_REGIDX_HORI_DISPLAY_ENABLE         1
127 #define CRTC_REGIDX_START_HORI_BLANKING         2
128 #define CRTC_REGIDX_END_HORI_BLANKING           3
129 #define CRTC_REGIDX_START_HORI_RETRACE          4
130 #define CRTC_REGIDX_END_HORI_RETRACE            5
131 #define CRTC_REGIDX_VERT_TOTAL                  6
132 #define CRTC_REGIDX_OVERFLOW                    7
133 #define CRTC_REGIDX_PRESET_ROW_SCAN             8
134 #define CRTC_REGIDX_MAX_SCAN_LINE               9
135 #define CRTC_REGIDX_CURSOR_START                10
136 #define CRTC_REGIDX_CURSOR_END                  11
137 #define CRTC_REGIDX_START_ADDR_HIGH             12
138 #define CRTC_REGIDX_START_ADDR_LOW              13
139 #define CRTC_REGIDX_CURSOR_LOC_HIGH             14
140 #define CRTC_REGIDX_CURSOR_LOC_LOW              15
141 #define CRTC_REGIDX_VERT_RETRACE_START          16
142 #define CRTC_REGIDX_VERT_RETRACE_END            17
143 #define CRTC_REGIDX_VERT_DISPLAY_ENABLE_END     18
144 #define CRTC_REGIDX_OFFSET                      19
145 #define CRTC_REGIDX_UNDERLINE_LOCATION          20
146 #define CRTC_REGIDX_START_VERT_BLANKING         21
147 #define CRTC_REGIDX_END_VERT_BLANKING           22
148 #define CRTC_REGIDX_CRT_MODE_CONTROL            23
149 #define CRTC_REGIDX_LINE_COMPATE                24
150
151 #define GRAPHC_REG_COUNT                9
152 #define GRAPHC_REGIDX_SET_RESET         0
153 #define GRAPHC_REGIDX_ENABLE_SET_RESET  1
154 #define GRAPHC_REGIDX_COLOR_COMPARE     2
155 #define GRAPHC_REGIDX_DATA_ROTATE       3
156 #define GRAPHC_REGIDX_READ_MAP_SELECT   4
157 #define GRAPHC_REGIDX_GRAPHICS_MODE     5
158 #define GRAPHC_REGIDX_MISC              6
159 #define GRAPHC_REGIDX_COLOR_DONT_CARE   7
160 #define GRAPHC_REGIDX_BIT_MASK          8
161
162 #define ATTRC_REG_COUNT                         21
163 #define ATTRC_REGIDX_PALETTE_0                  0
164 #define ATTRC_REGIDX_ATTR_MODE_CONTROL          16
165 #define ATTRC_REGIDX_OVERSCAN_COLOR             17
166 #define ATTRC_REGIDX_COLOR_PLANE_ENABLE         18
167 #define ATTRC_REGIDX_HORI_PEL_PANNING           19
168 #define ATTRC_REGIDX_COLOR_SELECT               20
169
170 #define DAC_ENTRY_COUNT                 256
171 #define DAC_COLOR_COUNT                 3
172 #define DAC_REG_COUNT                   (DAC_ENTRY_COUNT * DAC_COLOR_COUNT)
173
174 struct video_internal {
175     uint8_t * framebuf;
176     addr_t framebuf_pa;
177
178     /* registers */
179     struct misc_outp_reg misc_outp_reg;         // io port 3CC (R) / 3C2 (W)
180     uint8_t seq_index_reg;                      // io port 3C4
181     uint8_t seq_data_regs[SEQ_REG_COUNT];       // io port 3C5
182     uint8_t crtc_index_reg;                     // io port 3D4
183     uint8_t crtc_data_regs[CRTC_REG_COUNT];     // io port 3D5
184     uint8_t graphc_index_reg;                   // io port 3CE
185     uint8_t graphc_data_regs[GRAPHC_REG_COUNT]; // io port 3CF
186     uint8_t attrc_index_flipflop;
187     uint8_t attrc_index_reg;                    // io port 3C0
188     uint8_t attrc_data_regs[ATTRC_REG_COUNT];   // io port 3C1 (R) / 3C0 (W)
189     uint8_t dac_indexr_reg;                     // io port 3C8
190     uint8_t dac_indexr_color;
191     uint8_t dac_indexw_reg;                     // io port 3C7
192     uint8_t dac_indexw_color;
193     uint8_t dac_data_regs[DAC_REG_COUNT];       // io port 3C9
194
195     /* auxilary fields derived from register values */
196     addr_t activefb_addr;
197     uint_t activefb_len;
198     uint16_t iorange;
199     uint_t vres;
200     uint_t hres;
201     uint_t vchars;
202     uint_t hchars;
203     int graphmode;
204     
205     /* status */
206     int dirty;
207     int reschanged;
208
209     /* IMPORTANT: These are column offsets _NOT_ byte offsets */
210     uint16_t screen_offset; // relative to the framebuffer
211     uint16_t cursor_offset; // relative to the framebuffer
212     /* ** */
213
214     struct vm_device * dev;
215
216
217     uint8_t passthrough;
218
219
220     struct v3_console_ops * ops;
221     void * private_data;
222
223
224
225 };
226
227 static void refresh_screen(struct video_internal * state) {
228     uint_t screen_size;
229     
230     PrintDebug("Screen config: framebuf=0x%x-0x%x, gres=%dx%d, tres=%dx%d, %s mode\n", 
231         (unsigned) state->activefb_addr, 
232         (unsigned) state->activefb_addr + state->activefb_len, 
233         state->hres,
234         state->vres,
235         state->hchars,
236         state->vchars,
237         state->graphmode ? "graphics" : "text");
238     
239     /* tell the frontend to refresh the screen entirely */
240     state->dirty = 0;
241
242     if (state->reschanged) {
243         /* resolution change message will trigger update */
244         state->reschanged = 0;
245         PrintDebug("Video: set_text_resolution(%d, %d)\n", 
246             state->hchars, state->vchars);
247         if (state->ops && state->ops->set_text_resolution) {
248             state->ops->set_text_resolution(state->hchars, state->vchars, state->private_data);
249         }
250     } else {
251         /* send update for full buffer */
252         PrintDebug("Video: update_screen(0, 0, %d * %d * %d)\n", state->vchars, state->hchars, BYTES_PER_COL);
253         screen_size = state->vchars * state->hchars * BYTES_PER_COL;
254         if (state->ops) {
255             state->ops->update_screen(0, 0, screen_size, state->private_data);
256         }
257     }
258 }
259
260 static void registers_updated(struct video_internal * state) {
261     struct seq_data_reg_clocking_mode *cm;
262     struct graphc_data_reg_misc *misc;
263     struct crtc_data_reg_max_scan_line *msl;
264     struct crtc_data_reg_overflow *ovf;
265     int lines_per_char;
266     uint_t activefb_addr, activefb_len, hchars, vchars, vde, hres, vres;
267     
268     /* framebuffer mapping address */
269     misc = (struct graphc_data_reg_misc *)(state->graphc_data_regs + GRAPHC_REGIDX_MISC);
270
271     if (misc->mm >= 2) {
272         activefb_addr = (misc->mm == 3) ? 0xb8000 : 0xb0000;
273         activefb_len = 0x8000;
274     } else {
275         activefb_addr = 0xa0000;
276         activefb_len = (misc->mm == 1) ? 0x10000 : 0x20000;
277     }
278
279     if ((state->activefb_addr != activefb_addr) || (state->activefb_len != activefb_len)) {
280         state->activefb_addr = activefb_addr;
281         state->activefb_len = activefb_len;
282         state->dirty = 1;
283         PrintVerbose("Video: need refresh (activefb=0x%x-0x%x)\n", 
284             activefb_addr, activefb_addr + activefb_len);
285     } 
286     
287     /* mode selection; may be inconclusive, keep old value in that case */
288     if (state->graphmode != misc->gm) {
289         state->graphmode = misc->gm;
290         state->dirty = 1;
291         PrintVerbose("Video: need refresh (graphmode=%d)\n", state->graphmode);
292     }
293
294     /* graphics resolution */
295     if (state->misc_outp_reg.hsp) {
296         vres = (state->misc_outp_reg.vsp) ? 480 : 400;
297     } else {
298         if (!state->misc_outp_reg.vsp) {
299             PrintError("Video: reserved value in misc_outp_reg (0x%x)\n", 
300                 *(uint8_t *) &state->misc_outp_reg);
301         }
302         vres = 350;
303     }
304     msl = (struct crtc_data_reg_max_scan_line *) (
305         state->crtc_data_regs + CRTC_REGIDX_MAX_SCAN_LINE);
306     if (msl->dsc) vres /= 2;
307     if (state->vres != vres) {
308         state->vres = vres;
309         state->reschanged = 1;
310         PrintVerbose("Video: need refresh (vres=%d)\n", vres);
311     }
312     
313     switch (state->misc_outp_reg.cs) {
314         case 0: hres = 640; break;
315         case 1: hres = 720; break;
316         default:
317                 PrintError("Video: reserved value in misc_outp_reg (0x%x)\n", 
318                         *(uint8_t *) &state->misc_outp_reg);
319                 hres = 640;
320                 break;
321     }
322     cm = (struct seq_data_reg_clocking_mode *) (
323         state->seq_data_regs + SEQ_REGIDX_CLOCKING_MODE);
324     if (cm->dc) hres /= 2;
325     if (state->hres != hres) {
326         state->hres = hres;
327         state->reschanged = 1;
328         PrintVerbose("Video: need refresh (hres=%d)\n", hres);
329     }
330
331     /* text resolution */
332     ovf = (struct crtc_data_reg_overflow *) (state->crtc_data_regs + CRTC_REGIDX_OVERFLOW);
333     
334     hchars = state->crtc_data_regs[CRTC_REGIDX_HORI_DISPLAY_ENABLE] + 1;
335     lines_per_char = msl->msl + 1;
336     vde = state->crtc_data_regs[CRTC_REGIDX_VERT_DISPLAY_ENABLE_END] |
337         (((unsigned) ovf->vde8) << 8) | 
338         (((unsigned) ovf->vde9) << 9);
339     vchars = (vde + 1) / lines_per_char;
340     if (state->hchars != hchars || state->vchars != vchars) {
341         state->hchars = hchars;
342         state->vchars = vchars;
343         state->reschanged = 1;
344         PrintVerbose("Video: need refresh (hchars=%d, vchars=%d)\n", hchars, vchars);
345     }
346     
347     /* resolution change implies refresh needed */
348     if (state->reschanged) {
349         state->dirty = 1;
350     }
351
352     /* IO port range selection */
353     state->iorange = state->misc_outp_reg.ios ? 0x3d0 : 0x3b0;
354 }
355
356 static void registers_initialize(struct video_internal * state) {
357
358     /* initialize the registers; defaults taken from vgatables.h in the VGA 
359      * BIOS, mode 3 (which is specified by IBM as the default mode)
360      */
361     static const uint8_t seq_defaults[] = {
362         0x03, 0x00, 0x03, 0x00, 0x02,
363     };
364     static const uint8_t crtc_defaults[] = {
365         0x5f, 0x4f, 0x50, 0x82, /* 0 - 3 */
366         0x55, 0x81, 0xbf, 0x1f, /* 4 - 7 */
367         0x00, 0x4f, 0x0d, 0x0e, /* 8 - 11 */
368         0x00, 0x00, 0x00, 0x00, /* 12 - 15 */
369         0x9c, 0x8e, 0x8f, 0x28, /* 16 - 19 */
370         0x1f, 0x96, 0xb9, 0xa3, /* 20 - 23 */
371         0xff                    /* 24 */
372     };
373     static const uint8_t graphc_defaults[] = {
374         0x00, 0x00, 0x00, 0x00, /* 0 - 3 */
375         0x00, 0x10, 0x0e, 0x0f, /* 4 - 7 */
376         0xff                    /* 8 */
377     };
378     static const uint8_t attrc_defaults[] = {
379         0x00, 0x01, 0x02, 0x03, /* 0 - 3 */
380         0x04, 0x05, 0x14, 0x07, /* 4 - 7 */ 
381         0x38, 0x39, 0x3a, 0x3b, /* 8 - 11 */ 
382         0x3c, 0x3d, 0x3e, 0x3f, /* 12 - 15 */ 
383         0x0c, 0x00, 0x0f, 0x08, /* 16 - 19 */ 
384         0x00,                   /* 20 */
385     };
386  
387     /* general registers */
388     state->misc_outp_reg.ios = 1;
389     state->misc_outp_reg.eram = 1;
390     state->misc_outp_reg.cs = 1;
391     state->misc_outp_reg.hsp = 1;    
392     
393     /* sequencer registers */
394     V3_ASSERT(sizeof(seq_defaults) == sizeof(state->seq_data_regs));
395     memcpy(state->seq_data_regs, seq_defaults, sizeof(state->seq_data_regs));    
396     
397     /* CRT controller registers */
398     V3_ASSERT(sizeof(crtc_defaults) == sizeof(state->crtc_data_regs));
399     memcpy(state->crtc_data_regs, crtc_defaults, sizeof(state->crtc_data_regs));    
400     
401     /* graphics controller registers */
402     V3_ASSERT(sizeof(graphc_defaults) == sizeof(state->graphc_data_regs));
403     memcpy(state->graphc_data_regs, graphc_defaults, sizeof(state->graphc_data_regs));    
404     
405     /* attribute controller registers */
406     V3_ASSERT(sizeof(attrc_defaults) == sizeof(state->attrc_data_regs));
407     memcpy(state->attrc_data_regs, attrc_defaults, sizeof(state->attrc_data_regs));    
408     
409     /* initialize auxilary fields */
410     registers_updated(state);
411 }
412
413 static void passthrough_in(uint16_t port, void * src, uint_t length) {
414     switch (length) {
415         case 1:
416             *(uint8_t *)src = v3_inb(port);
417             break;
418         case 2:
419             *(uint16_t *)src = v3_inw(port);
420             break;
421         case 4:
422             *(uint32_t *)src = v3_indw(port);
423             break;
424         default:
425             break;
426     }
427 }
428
429
430 static void passthrough_out(uint16_t port, const void * src, uint_t length) {
431     switch (length) {
432         case 1:
433             v3_outb(port, *(uint8_t *)src);
434             break;
435         case 2:
436             v3_outw(port, *(uint16_t *)src);
437             break;
438         case 4:
439             v3_outdw(port, *(uint32_t *)src);
440             break;
441         default:
442             break;
443     }
444 }
445
446 #if V3_CONFIG_DEBUG_CGA >= 2
447 static unsigned long get_value(const void *ptr, int len) {
448   unsigned long value = 0;
449
450   if (len > sizeof(value)) len = sizeof(value);
451   memcpy(&value, ptr, len);
452
453   return value;
454 }
455
456 static char opsize_char(uint_t length) {
457     switch (length) {
458     case 1: return 'b'; 
459     case 2: return 'w'; 
460     case 4: return 'l'; 
461     case 8: return 'q';     
462     default: return '?'; 
463     }
464 }
465 #endif
466
467 static int video_write_mem(struct guest_info * core, addr_t guest_addr, void * dest, uint_t length, void * priv_data) {
468     struct vm_device * dev = (struct vm_device *)priv_data;
469     struct video_internal * state = (struct video_internal *)dev->private_data;
470     uint_t length_adjusted, screen_pos, x, y;
471     addr_t framebuf_offset, framebuf_offset_screen, screen_offset;
472     
473     V3_ASSERT(guest_addr >= START_ADDR);
474     V3_ASSERT(guest_addr < END_ADDR);
475     
476     PrintVerbose("Video: write(%p, 0x%lx, %d)\n", 
477        (void *)guest_addr, 
478         get_value(state->framebuf + (guest_addr - START_ADDR), length),
479         length);
480
481     /* get data written by passthrough into frame buffer if needed */
482     if (state->passthrough) {
483         memcpy(state->framebuf + (guest_addr - START_ADDR), V3_VAddr((void *)guest_addr), length);
484     }
485     
486     /* refresh the entire screen after the registers have been changed */
487     if (state->dirty) {
488         refresh_screen(state);
489         return length;
490     }
491     
492     /* the remainder is only needed if there is a front-end */
493     if (!state->ops) {
494         return length;
495     }
496
497     /* write may point into a framebuffer not currently active, for example 
498      * preparing a VGA buffer at 0xA0000 while the CGA text mode at 0xB8000 
499      * is still on the display; in this case we have to ignore (part of) the 
500      * write to avoid buffer overflows
501      */
502     length_adjusted = length;
503     if (state->activefb_addr > guest_addr) {
504         uint_t diff = state->activefb_addr - guest_addr;
505         if (diff >= length_adjusted) return length;
506         guest_addr += diff;
507         length_adjusted -= diff;
508     }
509
510     framebuf_offset = guest_addr - state->activefb_addr;
511     if (state->activefb_len <= framebuf_offset) return length;
512     if (length_adjusted > state->activefb_len - framebuf_offset) {
513         length_adjusted = state->activefb_len - framebuf_offset;
514     }
515
516     /* determine position on screen, considering wrapping */
517     framebuf_offset_screen = state->screen_offset * BYTES_PER_COL;
518     if (framebuf_offset > framebuf_offset_screen) {
519         screen_offset = framebuf_offset - framebuf_offset_screen;
520     } else {
521         screen_offset = framebuf_offset + state->activefb_len - framebuf_offset_screen;
522     }
523     
524     /* translate to coordinates and pass to the frontend */
525     screen_pos = screen_offset / BYTES_PER_COL;
526     x = screen_pos % state->hchars;
527     y = screen_pos / state->hchars;
528     if (y >= state->vchars) return length;
529     PrintVerbose("Video: update_screen(%d, %d, %d)\n", x, y, length_adjusted);
530     state->ops->update_screen(x, y, length_adjusted, state->private_data);
531
532     return length;
533 }
534
535 static void debug_port(struct video_internal * video_state, const char *function, uint16_t port, uint_t length, uint_t maxlength)
536 {
537     uint16_t portrange = port & 0xfff0;
538
539     /* report any unexpected guest behaviour, it may explain failures */
540     if (portrange != 0x3c0 && portrange != video_state->iorange) {
541         PrintError("Video %s: got bad port 0x%x\n", function, port);
542     }
543
544     if (!video_state->passthrough && length > maxlength) {
545         PrintError("Video %s: got bad length %d\n", function, length);
546     }
547     V3_ASSERT(length >= 1);
548 }
549
550 static void handle_port_read(struct video_internal * video_state, const char *function, uint16_t port, void *dest, uint_t length, uint_t maxlength) {
551     PrintVerbose("Video %s: in%c(0x%x): 0x%lx\n", function, opsize_char(length), port, get_value(dest, length));
552     debug_port(video_state, function, port, length, maxlength);
553
554     if (video_state->passthrough) {
555         passthrough_in(port, dest, length);
556     }
557 }
558
559 static void handle_port_write(struct video_internal * video_state, const char *function, uint16_t port, const void *src, uint_t length, uint_t maxlength) {
560     PrintVerbose("Video %s: out%c(0x%x, 0x%lx)\n", function, opsize_char(length), port, get_value(src, length));
561     debug_port(video_state, function, port, length, maxlength);
562
563     if (video_state->passthrough) {
564         passthrough_out(port, src, length);
565     }
566 }
567
568 static int notimpl_port_read(struct video_internal * video_state, const char *function, uint16_t port, void *dest, uint_t length) {
569     memset(dest, 0xff, length);
570     handle_port_read(video_state, function, port, dest, length, 1);
571     if (!video_state->passthrough) {
572         PrintError("Video %s: not implemented\n", function);
573     }
574     return length;
575 }
576
577 static int notimpl_port_write(struct video_internal * video_state, const char *function, uint16_t port, const void *src, uint_t length) {
578     handle_port_write(video_state, function, port, src, length, 1);
579     if (!video_state->passthrough) {
580         PrintError("Video %s: not implemented\n", function);
581     }
582     return length;
583 }
584
585 /* general registers */
586 static int misc_outp_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
587     struct video_internal * video_state = priv_data;
588
589     *(struct misc_outp_reg *) dest = video_state->misc_outp_reg;
590
591     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
592     return length;
593 }
594
595 static int misc_outp_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
596     struct video_internal * video_state = priv_data;
597     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
598
599     PrintDebug("Video: misc_outp=0x%x\n", *(uint8_t *) src);
600     video_state->misc_outp_reg = *(struct misc_outp_reg *) src;
601     registers_updated(video_state);
602
603     return length;
604 }
605
606 static int inp_status0_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
607     return notimpl_port_read(priv_data, __FUNCTION__, port, dest, length);
608 }
609
610 static int inp_status1_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
611     struct video_internal * video_state = priv_data;
612
613     /* next write to attrc selects the index rather than data */
614     video_state->attrc_index_flipflop = 0;
615
616     return notimpl_port_read(priv_data, __FUNCTION__, port, dest, length);
617 }
618
619 static int feat_ctrl_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
620     return notimpl_port_read(priv_data, __FUNCTION__, port, dest, length);
621 }
622
623 static int feat_ctrl_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
624     return notimpl_port_write(priv_data, __FUNCTION__, port, src, length);
625 }
626
627 static int video_enable_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
628     return notimpl_port_read(priv_data, __FUNCTION__, port, dest, length);
629 }
630
631 static int video_enable_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
632     return notimpl_port_write(priv_data, __FUNCTION__, port, src, length);
633 }
634
635 /* sequencer registers */
636 static int seq_data_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
637     struct video_internal * video_state = priv_data;
638     int index = video_state->seq_index_reg;
639
640     if (index < SEQ_REG_COUNT) {
641         *(uint8_t *) dest = video_state->seq_data_regs[index];
642     } else {
643         PrintError("Video %s: index %d out of range\n", __FUNCTION__, video_state->seq_index_reg);
644         *(uint8_t *) dest = 0;
645     }
646
647     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
648     return length;    
649 }
650
651 static int seq_data_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
652     struct video_internal * video_state = priv_data;
653     int index = video_state->seq_index_reg;
654     uint8_t val = *(uint8_t *) src;
655     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
656
657     if (index < SEQ_REG_COUNT) {
658         PrintDebug("Video: seq[%d]=0x%x\n", index, val);
659         video_state->seq_data_regs[index] = val;
660         registers_updated(video_state);
661     } else {
662         PrintError("Video %s: index %d out of range\n", __FUNCTION__, video_state->seq_index_reg);
663     }
664
665     return length;    
666 }
667
668 static int seq_index_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
669     struct video_internal * video_state = priv_data;
670
671     *(uint8_t *) dest = video_state->seq_index_reg;
672
673     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
674     return length;
675 }
676
677 static int seq_index_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
678     struct video_internal * video_state = priv_data;
679     handle_port_write(video_state, __FUNCTION__, port, src, length, 2);
680
681     video_state->seq_index_reg = *(uint8_t *) src;
682
683     if (length > 1) {
684         if (seq_data_write(core, port + 1, (uint8_t *) src + 1, length - 1, priv_data) != length - 1) {
685             return -1;
686         }
687     }
688
689     return length;    
690 }
691
692 /* CRT controller registers */
693 static int crtc_data_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
694     struct video_internal * video_state = priv_data;
695
696     *(uint8_t *) dest = video_state->crtc_index_reg;
697
698     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
699     return length;
700 }
701
702 static int crtc_data_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
703     struct video_internal * video_state = priv_data;
704     uint8_t val = *(uint8_t *)src;
705     uint_t index = video_state->crtc_index_reg;
706
707     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
708     if (length != 1) {
709         PrintError("Invalid write length for port 0x%x\n", port);
710         return -1;
711     }
712
713     video_state->crtc_data_regs[index] = val;
714     registers_updated(video_state);
715
716     switch (index) {
717
718         case CRTC_REGIDX_START_ADDR_HIGH: break; // Dealt by low-order byte write
719         case CRTC_REGIDX_START_ADDR_LOW: {  // Scroll low byte
720             int diff, refresh;
721             uint_t screen_offset;
722
723             screen_offset =
724                 ((uint16_t) video_state->crtc_data_regs[CRTC_REGIDX_START_ADDR_HIGH] << 8) |
725                 ((uint16_t) video_state->crtc_data_regs[CRTC_REGIDX_START_ADDR_LOW]);
726             if ((screen_offset - video_state->screen_offset) % video_state->hchars) {
727                 /* diff is not a multiple of column count, need full refresh */
728                 diff = 0;
729                 refresh = 1;
730             } else {
731                 /* normal scroll (the common case) */
732                 diff = (screen_offset - video_state->screen_offset) / video_state->hchars;
733                 refresh = 0;
734             }
735             PrintVerbose("Video: screen_offset=%d, video_state->screen_offset=%d, video_state->hchars=%d, diff=%d, refresh=%d\n",
736                 screen_offset, video_state->screen_offset, video_state->hchars, diff, refresh);
737
738             // Update the true offset value
739             video_state->screen_offset = screen_offset;
740
741             if (refresh || video_state->dirty) {
742                 refresh_screen(video_state);
743             } else if (diff && video_state->ops) {
744                 PrintVerbose("Video: scroll(%d)\n", diff);
745                 if (video_state->ops->scroll(diff, video_state->private_data) == -1) {
746                     PrintError("Error sending scroll event\n");
747                     return -1;
748                 }
749             }
750             break;
751         }
752         case CRTC_REGIDX_CURSOR_LOC_HIGH: break; // Dealt by low-order byte write
753         case CRTC_REGIDX_CURSOR_LOC_LOW: { // Cursor adjustment low byte
754             uint_t x;
755             uint_t y;
756             
757             video_state->cursor_offset =
758                 ((uint16_t) video_state->crtc_data_regs[CRTC_REGIDX_CURSOR_LOC_HIGH] << 8) |
759                 ((uint16_t) video_state->crtc_data_regs[CRTC_REGIDX_CURSOR_LOC_LOW]);
760             x = video_state->cursor_offset % video_state->hchars;
761             y = (video_state->cursor_offset - video_state->screen_offset) / video_state->hchars;
762             PrintVerbose("Video: video_state->cursor_offset=%d, x=%d, y=%d\n",
763                 video_state->cursor_offset, x, y);
764
765             if (video_state->dirty) {
766                 refresh_screen(video_state);
767             }
768             
769             PrintVerbose("Video: set cursor(%d, %d)\n", x, y);
770             if (video_state->ops) {
771                 if (video_state->ops->update_cursor(x, y, video_state->private_data) == -1) {
772                     PrintError("Error updating cursor\n");
773                     return -1;
774                 }
775             } 
776
777             break;
778         }
779         default:
780             PrintDebug("Video: crtc[%d]=0x%x\n", index, val);
781             break;
782     }
783
784     if (video_state->passthrough) {
785         passthrough_out(port, src, length);
786     }
787
788     return length;
789 }
790
791 static int crtc_index_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
792     struct video_internal * video_state = priv_data;
793
794     *(uint8_t *) dest = video_state->crtc_index_reg;
795
796     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
797     return length;
798 }
799
800 static int crtc_index_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
801     struct video_internal * video_state = priv_data;
802
803     handle_port_write(video_state, __FUNCTION__, port, src, length, 2);
804     if (length > 2) {
805         PrintError("Invalid write length for crtc index register port: %d (0x%x)\n",
806                    port, port);
807         return -1;
808     }
809
810     video_state->crtc_index_reg = *(uint8_t *)src;
811
812     // Only do the passthrough IO for the first byte
813     // the second byte will be done in the data register handler
814     if (video_state->passthrough) {
815         passthrough_out(port, src, 1);
816     }
817
818     if (length > 1) {
819         if (crtc_data_write(core, port + 1, (uint8_t *) src + 1, length - 1, priv_data) != length - 1) {
820             return -1;
821         }
822     }
823
824     return length;
825 }
826
827 /* graphics controller registers */
828 static int graphc_data_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
829     struct video_internal * video_state = priv_data;
830     int index = video_state->graphc_index_reg;
831
832     if (index < GRAPHC_REG_COUNT) {
833         *(uint8_t *) dest = video_state->graphc_data_regs[index];
834     } else {
835         PrintError("Video %s: index %d out of range\n", __FUNCTION__, video_state->graphc_index_reg);
836         *(uint8_t *) dest = 0;
837     }
838
839     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
840     return length;    
841 }
842
843 static int graphc_data_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
844     struct video_internal * video_state = priv_data;
845     int index = video_state->graphc_index_reg;
846     uint8_t val = *(uint8_t *) src;
847     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
848
849     if (index < GRAPHC_REG_COUNT) {
850         PrintDebug("Video: graphc[%d]=0x%x\n", index, val);
851         video_state->graphc_data_regs[index] = val;
852         registers_updated(video_state);
853     } else {
854         PrintError("Video %s: index %d out of range\n", __FUNCTION__, video_state->graphc_index_reg);
855     }
856
857     return length;    
858 }
859
860 static int graphc_index_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
861     struct video_internal * video_state = priv_data;
862
863     *(uint8_t *) dest = video_state->graphc_index_reg;
864
865     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
866     return length;
867 }
868
869 static int graphc_index_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
870     struct video_internal * video_state = priv_data;
871     handle_port_write(video_state, __FUNCTION__, port, src, length, 2);
872
873     video_state->graphc_index_reg = *(uint8_t *) src;
874
875     if (length > 1) {
876         if (graphc_data_write(core, port + 1, (uint8_t *) src + 1, length - 1, priv_data) != length - 1) {
877             return -1;
878         }
879     }
880     
881     return length;    
882 }
883
884 /* attribute controller registers */
885 static int attrc_data_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
886     struct video_internal * video_state = priv_data;
887     int index = video_state->attrc_index_reg;
888
889     if (index < ATTRC_REG_COUNT) {
890         *(uint8_t *) dest = video_state->attrc_data_regs[index];
891     } else {
892         PrintError("Video %s: index %d out of range\n", __FUNCTION__, video_state->attrc_index_reg);
893         *(uint8_t *) dest = 0;
894     }
895
896     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
897     return length;    
898 }
899
900 static int attrc_data_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
901     struct video_internal * video_state = priv_data;
902     int index = video_state->attrc_index_reg;
903     uint8_t val = *(uint8_t *) src;
904     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
905
906     if (index < ATTRC_REG_COUNT) {
907         PrintDebug("Video: attrc[%d]=0x%x\n", index, val);
908         video_state->attrc_data_regs[index] = val;
909     } else {
910         PrintError("Video %s: index %d out of range\n", __FUNCTION__, video_state->attrc_index_reg);
911     }
912
913     return length;    
914 }
915
916 static int attrc_index_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
917     struct video_internal * video_state = priv_data;
918
919     *(uint8_t *) dest = video_state->attrc_index_reg;
920
921     if (length > 1) {
922         if (attrc_data_read(core, port + 1, (uint8_t *) dest + 1, length - 1, priv_data) != length - 1) {
923             return -1;
924         }
925     }
926     
927     handle_port_read(video_state, __FUNCTION__, port, dest, length, 2);
928     return length;
929 }
930
931 static int attrc_index_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
932     struct video_internal * video_state = priv_data;
933     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
934
935     video_state->attrc_index_reg = *(uint8_t *) src;
936
937     return length;    
938 }
939
940 static int attrc_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
941     struct video_internal * video_state = priv_data;
942
943     /* two registers in one, written in an alternating fashion */
944     if (video_state->attrc_index_flipflop) {
945         video_state->attrc_index_flipflop = 0;
946         return attrc_data_write(core, port, src, length, priv_data);
947     } else {
948         video_state->attrc_index_flipflop = 1;
949         return attrc_index_write(core, port, src, length, priv_data);
950     }
951 }
952
953 /* video DAC palette registers */
954 static int dac_indexw_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
955     struct video_internal * video_state = priv_data;
956
957     *(uint8_t *) dest = video_state->dac_indexw_reg;
958
959     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
960     return length;
961 }
962
963 static int dac_indexw_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
964     struct video_internal * video_state = priv_data;
965     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
966
967     video_state->dac_indexw_reg = *(uint8_t *) src;
968     video_state->dac_indexw_color = 0;
969
970     return length;  
971 }
972
973 static int dac_indexr_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
974     struct video_internal * video_state = priv_data;
975     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
976
977     video_state->dac_indexr_reg = *(uint8_t *) src;
978     video_state->dac_indexr_color = 0;
979
980     return length;  
981 }
982
983 static int dac_data_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
984     struct video_internal * video_state = priv_data;
985     unsigned index;
986
987     /* update palette */
988     index = (unsigned) video_state->dac_indexr_reg * DAC_COLOR_COUNT + 
989         video_state->dac_indexr_color;
990     V3_ASSERT(index < DAC_REG_COUNT);
991     *(uint8_t *) dest = video_state->dac_data_regs[index];
992     
993     /* move on to next entry/color */
994     if (++video_state->dac_indexr_color > DAC_COLOR_COUNT) {
995         video_state->dac_indexr_reg++;
996         video_state->dac_indexr_color -= DAC_COLOR_COUNT;
997     }
998
999     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
1000     return length;
1001 }
1002
1003 static int dac_data_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
1004     struct video_internal * video_state = priv_data;
1005     unsigned index;
1006     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
1007
1008     /* update palette */
1009     index = (unsigned) video_state->dac_indexw_reg * DAC_COLOR_COUNT + 
1010         video_state->dac_indexw_color;
1011     V3_ASSERT(index < DAC_REG_COUNT);
1012     video_state->dac_data_regs[index] = *(uint8_t *) src;
1013     
1014     /* move on to next entry/color */
1015     if (++video_state->dac_indexw_color > DAC_COLOR_COUNT) {
1016         video_state->dac_indexw_reg++;
1017         video_state->dac_indexw_color -= DAC_COLOR_COUNT;
1018     }
1019
1020     return length;
1021 }
1022
1023 static int dac_pelmask_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
1024     return notimpl_port_read(priv_data, __FUNCTION__, port, dest, length);
1025 }
1026
1027 static int dac_pelmask_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
1028     return notimpl_port_write(priv_data, __FUNCTION__, port, src, length);
1029 }
1030
1031
1032 static int v3_cons_get_fb_graph(struct video_internal * state, uint8_t * dst, uint_t offset, uint_t length) {
1033     char c, text[80];
1034     uint_t textlength, textoffset, textsize;
1035
1036     /* this call is not intended for graphics mode, tell the user this */
1037
1038     /* center informative text on 10th line */
1039     snprintf(text, sizeof(text), "* * * GRAPHICS MODE %dx%d * * *",
1040         state->hres, state->vres);
1041     textlength = strlen(text);
1042     textoffset = (state->hchars * 9 + (state->hchars - textlength) / 2) * BYTES_PER_COL;
1043     textsize = textlength * BYTES_PER_COL;
1044
1045     /* fill the buffer */
1046     while (length-- > 0) {
1047         if (offset % BYTES_PER_COL) {
1048             c = 0; /* attribute byte */
1049         } else if (offset < textoffset || offset - textoffset >= textsize) {
1050             c = ' '; /* unused character byte */
1051         } else {
1052             c = text[(offset - textoffset) / BYTES_PER_COL];
1053         }
1054
1055         *(dst++) = c;
1056         offset++;
1057     }
1058
1059     return 0;
1060 }
1061
1062 static uint_t min_uint(uint_t x, uint_t y) {
1063     return (x < y) ? x : y;
1064 }
1065
1066 int v3_cons_get_fb_text(struct video_internal * state, uint8_t * dst, uint_t offset, uint_t length) {
1067     uint8_t *framebuf;
1068     uint_t framebuf_offset, len1, len2;
1069     uint_t screen_byte_offset = state->screen_offset * BYTES_PER_COL;
1070
1071     PrintVerbose("Video: getfb o=%d l=%d so=%d aa=0x%x al=0x%x hc=%d vc=%d\n",
1072         offset, length, state->screen_offset, 
1073         (unsigned) state->activefb_addr, (unsigned) state->activefb_len,
1074         state->hchars, state->vchars);
1075     V3_ASSERT(state->activefb_addr >= START_ADDR);
1076     V3_ASSERT(state->activefb_addr + state->activefb_len <= END_ADDR);
1077
1078     /* Copy memory with wrapping (should be configurable, but where else to get the data?) */
1079     framebuf = state->framebuf + (state->activefb_addr - START_ADDR);
1080     framebuf_offset = (screen_byte_offset + offset) % state->activefb_len;
1081     len1 = min_uint(length, state->activefb_len - framebuf_offset);
1082     len2 = length - len1;
1083     if (len1 > 0) memcpy(dst, framebuf + framebuf_offset, len1);
1084     if (len2 > 0) memcpy(dst + len1, framebuf, len2);
1085
1086     return 0;
1087 }
1088
1089 int v3_cons_get_fb(struct vm_device * frontend_dev, uint8_t * dst, uint_t offset, uint_t length) {
1090     struct video_internal * state = (struct video_internal *)frontend_dev->private_data;
1091
1092     /* Deal with call depending on mode */
1093     if (state->graphmode) {
1094         return v3_cons_get_fb_graph(state, dst, offset, length);
1095     } else {
1096         return v3_cons_get_fb_text(state, dst, offset, length);
1097     }
1098 }
1099
1100 static int cga_free(struct video_internal * video_state) {
1101
1102     if (video_state->framebuf_pa) {
1103         PrintError("Freeing framebuffer PA %p\n", (void *)(video_state->framebuf_pa));
1104         V3_FreePages((void *)(video_state->framebuf_pa), (FRAMEBUF_SIZE / 4096));
1105     }
1106
1107     v3_unhook_mem(video_state->dev->vm, V3_MEM_CORE_ANY, START_ADDR);
1108
1109     V3_Free(video_state);
1110
1111     return 0;
1112 }
1113
1114
1115 #ifdef V3_CONFIG_CHECKPOINT
1116 static int cga_save(struct v3_chkpt_ctx * ctx, void * private_data) {
1117     struct video_internal * cga = (struct video_internal *)private_data;
1118
1119     v3_chkpt_save(ctx, "FRAMEBUFFER", FRAMEBUF_SIZE, cga->framebuf);
1120
1121     V3_CHKPT_STD_SAVE(ctx, cga->misc_outp_reg);
1122     V3_CHKPT_STD_SAVE(ctx, cga->seq_index_reg);         
1123     V3_CHKPT_STD_SAVE(ctx, cga->seq_data_regs[SEQ_REG_COUNT]);  
1124     V3_CHKPT_STD_SAVE(ctx, cga->crtc_index_reg);                
1125     V3_CHKPT_STD_SAVE(ctx, cga->crtc_data_regs[CRTC_REG_COUNT]);
1126     V3_CHKPT_STD_SAVE(ctx, cga->graphc_index_reg);              
1127     V3_CHKPT_STD_SAVE(ctx, cga->graphc_data_regs[GRAPHC_REG_COUNT]);
1128     V3_CHKPT_STD_SAVE(ctx, cga->attrc_index_flipflop);
1129     V3_CHKPT_STD_SAVE(ctx, cga->attrc_index_reg);       
1130     V3_CHKPT_STD_SAVE(ctx, cga->attrc_data_regs[ATTRC_REG_COUNT]);      
1131     V3_CHKPT_STD_SAVE(ctx, cga->dac_indexr_reg);        
1132     V3_CHKPT_STD_SAVE(ctx, cga->dac_indexr_color);
1133     V3_CHKPT_STD_SAVE(ctx, cga->dac_indexw_reg);                
1134     V3_CHKPT_STD_SAVE(ctx, cga->dac_indexw_color);
1135     V3_CHKPT_STD_SAVE(ctx, cga->dac_data_regs[DAC_REG_COUNT]);
1136
1137     V3_CHKPT_STD_SAVE(ctx, cga->activefb_addr);
1138     V3_CHKPT_STD_SAVE(ctx, cga->activefb_len);
1139     V3_CHKPT_STD_SAVE(ctx, cga->iorange);
1140     V3_CHKPT_STD_SAVE(ctx, cga->vres);
1141     V3_CHKPT_STD_SAVE(ctx, cga->hres);
1142     V3_CHKPT_STD_SAVE(ctx, cga->vchars);
1143     V3_CHKPT_STD_SAVE(ctx, cga->hchars);
1144     V3_CHKPT_STD_SAVE(ctx, cga->graphmode);
1145
1146     V3_CHKPT_STD_SAVE(ctx, cga->dirty);
1147     V3_CHKPT_STD_SAVE(ctx, cga->reschanged);
1148
1149     V3_CHKPT_STD_SAVE(ctx, cga->passthrough);
1150
1151     v3_chkpt_save_16(ctx, "SCREEN_OFFSET", &(cga->screen_offset));
1152     v3_chkpt_save_16(ctx, "CURSOR_OFFSET", &(cga->cursor_offset));
1153
1154     return 0;
1155 }
1156
1157 static int cga_load(struct v3_chkpt_ctx * ctx, void * private_data) {
1158     struct video_internal * cga = (struct video_internal *)private_data;
1159
1160     v3_chkpt_load(ctx, "FRAMEBUFFER", FRAMEBUF_SIZE, cga->framebuf);
1161
1162
1163     V3_CHKPT_STD_LOAD(ctx, cga->misc_outp_reg);
1164     V3_CHKPT_STD_LOAD(ctx, cga->seq_index_reg);         
1165     V3_CHKPT_STD_LOAD(ctx, cga->seq_data_regs[SEQ_REG_COUNT]);  
1166     V3_CHKPT_STD_LOAD(ctx, cga->crtc_index_reg);                
1167     V3_CHKPT_STD_LOAD(ctx, cga->crtc_data_regs[CRTC_REG_COUNT]);
1168     V3_CHKPT_STD_LOAD(ctx, cga->graphc_index_reg);              
1169     V3_CHKPT_STD_LOAD(ctx, cga->graphc_data_regs[GRAPHC_REG_COUNT]);
1170     V3_CHKPT_STD_LOAD(ctx, cga->attrc_index_flipflop);
1171     V3_CHKPT_STD_LOAD(ctx, cga->attrc_index_reg);       
1172     V3_CHKPT_STD_LOAD(ctx, cga->attrc_data_regs[ATTRC_REG_COUNT]);      
1173     V3_CHKPT_STD_LOAD(ctx, cga->dac_indexr_reg);        
1174     V3_CHKPT_STD_LOAD(ctx, cga->dac_indexr_color);
1175     V3_CHKPT_STD_LOAD(ctx, cga->dac_indexw_reg);                
1176     V3_CHKPT_STD_LOAD(ctx, cga->dac_indexw_color);
1177     V3_CHKPT_STD_LOAD(ctx, cga->dac_data_regs[DAC_REG_COUNT]);
1178
1179     V3_CHKPT_STD_LOAD(ctx, cga->activefb_addr);
1180     V3_CHKPT_STD_LOAD(ctx, cga->activefb_len);
1181     V3_CHKPT_STD_LOAD(ctx, cga->iorange);
1182     V3_CHKPT_STD_LOAD(ctx, cga->vres);
1183     V3_CHKPT_STD_LOAD(ctx, cga->hres);
1184     V3_CHKPT_STD_LOAD(ctx, cga->vchars);
1185     V3_CHKPT_STD_LOAD(ctx, cga->hchars);
1186     V3_CHKPT_STD_LOAD(ctx, cga->graphmode);
1187
1188     V3_CHKPT_STD_LOAD(ctx, cga->dirty);
1189     V3_CHKPT_STD_LOAD(ctx, cga->reschanged);
1190
1191     V3_CHKPT_STD_LOAD(ctx, cga->passthrough);
1192
1193     v3_chkpt_load_16(ctx, "SCREEN_OFFSET", &(cga->screen_offset));
1194     v3_chkpt_load_16(ctx, "CURSOR_OFFSET", &(cga->cursor_offset));
1195
1196
1197     return 0;
1198 }
1199
1200 #endif
1201
1202
1203 static struct v3_device_ops dev_ops = {
1204     .free = (int (*)(void *))cga_free,
1205 #ifdef V3_CONFIG_CHECKPOINT
1206     .save = cga_save, 
1207     .load = cga_load
1208 #endif
1209
1210 };
1211
1212 static int cga_init(struct v3_vm_info * vm, v3_cfg_tree_t * cfg) {
1213     struct video_internal * video_state = NULL;
1214     char * dev_id = v3_cfg_val(cfg, "ID");
1215     char * passthrough_str = v3_cfg_val(cfg, "passthrough");
1216     int ret = 0;
1217     
1218     PrintDebug("video: init_device\n");
1219
1220     video_state = (struct video_internal *)V3_Malloc(sizeof(struct video_internal));
1221     memset(video_state, 0, sizeof(struct video_internal));
1222
1223     struct vm_device * dev = v3_add_device(vm, dev_id, &dev_ops, video_state);
1224
1225     if (dev == NULL) {
1226         PrintError("Could not attach device %s\n", dev_id);
1227         V3_Free(video_state);
1228         return -1;
1229     }
1230   
1231     video_state->dev = dev;
1232
1233     video_state->framebuf_pa = (addr_t)V3_AllocPages(FRAMEBUF_SIZE / 4096);
1234     video_state->framebuf = V3_VAddr((void *)(video_state->framebuf_pa));
1235     memset(video_state->framebuf, 0, FRAMEBUF_SIZE);
1236
1237     PrintDebug("PA of array: %p\n", (void *)(video_state->framebuf_pa));
1238
1239     if ((passthrough_str != NULL) &&
1240         (strcasecmp(passthrough_str, "enable") == 0)) {;
1241         video_state->passthrough = 1;
1242     }
1243
1244
1245     if (video_state->passthrough) {
1246         PrintDebug("Enabling CGA Passthrough\n");
1247         if (v3_hook_write_mem(vm, V3_MEM_CORE_ANY, START_ADDR, END_ADDR, 
1248                               START_ADDR, &video_write_mem, dev) == -1) {
1249             PrintError("\n\nVideo Hook failed.\n\n");
1250             return -1;
1251         }
1252     } else {
1253         if (v3_hook_write_mem(vm, V3_MEM_CORE_ANY, START_ADDR, END_ADDR, 
1254                               video_state->framebuf_pa, &video_write_mem, dev) == -1) {
1255             PrintError("\n\nVideo Hook failed.\n\n");
1256             return -1;
1257         }
1258     }
1259
1260     /* registers according to http://www.mcamafia.de/pdf/ibm_vgaxga_trm2.pdf */
1261
1262     /* general registers */
1263     ret |= v3_dev_hook_io(dev, 0x3cc, &misc_outp_read, NULL);
1264     ret |= v3_dev_hook_io(dev, 0x3c2, &inp_status0_read, &misc_outp_write);
1265     ret |= v3_dev_hook_io(dev, 0x3ba, &inp_status1_read, &feat_ctrl_write);
1266     ret |= v3_dev_hook_io(dev, 0x3da, &inp_status1_read, &feat_ctrl_write);
1267     ret |= v3_dev_hook_io(dev, 0x3ca, &feat_ctrl_read, NULL);
1268     ret |= v3_dev_hook_io(dev, 0x3c3, &video_enable_read, &video_enable_write);
1269
1270     /* sequencer registers */
1271     ret |= v3_dev_hook_io(dev, 0x3c4, &seq_index_read, &seq_index_write);
1272     ret |= v3_dev_hook_io(dev, 0x3c5, &seq_data_read, &seq_data_write);
1273
1274     /* CRT controller registers, both CGA and VGA ranges */
1275     ret |= v3_dev_hook_io(dev, 0x3b4, &crtc_index_read, &crtc_index_write);
1276     ret |= v3_dev_hook_io(dev, 0x3b5, &crtc_data_read, &crtc_data_write);
1277     ret |= v3_dev_hook_io(dev, 0x3d4, &crtc_index_read, &crtc_index_write);
1278     ret |= v3_dev_hook_io(dev, 0x3d5, &crtc_data_read, &crtc_data_write);
1279
1280     /* graphics controller registers */
1281     ret |= v3_dev_hook_io(dev, 0x3ce, &graphc_index_read, &graphc_index_write);
1282     ret |= v3_dev_hook_io(dev, 0x3cf, &graphc_data_read, &graphc_data_write);
1283
1284     /* attribute controller registers */
1285     ret |= v3_dev_hook_io(dev, 0x3c0, &attrc_index_read, &attrc_write);
1286     ret |= v3_dev_hook_io(dev, 0x3c1, &attrc_data_read, NULL);
1287
1288     /* video DAC palette registers */
1289     ret |= v3_dev_hook_io(dev, 0x3c8, &dac_indexw_read, &dac_indexw_write);
1290     ret |= v3_dev_hook_io(dev, 0x3c7, NULL, &dac_indexr_write);
1291     ret |= v3_dev_hook_io(dev, 0x3c9, &dac_data_read, &dac_data_write);
1292     ret |= v3_dev_hook_io(dev, 0x3c6, &dac_pelmask_read, &dac_pelmask_write);
1293
1294     if (ret != 0) {
1295         PrintError("Error allocating VGA IO ports\n");
1296         v3_remove_device(dev);
1297         return -1;
1298     }
1299
1300     /* initialize the state as it is at boot time */
1301     registers_initialize(video_state);
1302
1303     return 0;
1304 }
1305
1306 device_register("CGA_VIDEO", cga_init);
1307
1308
1309 int v3_console_register_cga(struct vm_device * cga_dev, struct v3_console_ops * ops, void * private_data) {
1310     struct video_internal * video_state = (struct video_internal *)cga_dev->private_data;
1311     
1312     video_state->ops = ops;
1313     video_state->private_data = private_data;
1314
1315     return 0;
1316 }