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.
6 * The V3VEE Project is a joint project between Northwestern University
7 * and the University of New Mexico. You can find out more at
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.
15 * Author: Robdert Deloatch <rtdeloatch@gmail.com>
16 * Steven Jaconette <stevenjaconette2007@u.northwestern.edu>
18 * This is free software. You are permitted to use,
19 * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
22 #include <palacios/vmm.h>
23 #include <palacios/vmm_dev_mgr.h>
24 #include <palacios/vmm_emulator.h>
25 #include <palacios/vm_guest_mem.h>
26 #include <palacios/vmm_io.h>
28 #include <devices/console.h>
35 #define PrintDebug(fmt, args...)
39 #define START_ADDR 0xB8000
40 #define END_ADDR 0xC0000
42 #define FRAMEBUF_SIZE (END_ADDR - START_ADDR)
43 #define SCREEN_SIZE 4000
45 #define BASE_CGA_PORT 0x3B0
49 #define BYTES_PER_ROW (NUM_COLS * 2)
50 #define BYTES_PER_COL 2
53 struct video_internal {
57 // These store the values for unhandled ports, in case of a read op
58 uint8_t port_store[44];
61 uint8_t crtc_index_reg; // io port 3D4
62 uint8_t crtc_data_regs[25]; // io port 3D5
64 /* IMPORTANT: These are column offsets _NOT_ byte offsets */
65 uint16_t screen_offset; // relative to the framebuffer
66 uint16_t cursor_offset; // relative to the framebuffer
69 // updating the screen offset is not atomic,
70 // so we need a temp variable to hold the partial update
71 uint16_t tmp_screen_offset;
77 struct v3_console_ops * ops;
87 static void passthrough_in(uint16_t port, void * src, uint_t length) {
90 *(uint8_t *)src = v3_inb(port);
93 *(uint16_t *)src = v3_inw(port);
96 *(uint32_t *)src = v3_indw(port);
104 static void passthrough_out(uint16_t port, void * src, uint_t length) {
107 v3_outb(port, *(uint8_t *)src);
110 v3_outw(port, *(uint16_t *)src);
113 v3_outdw(port, *(uint32_t *)src);
120 static int video_write_mem(struct guest_info * core, addr_t guest_addr, void * dest, uint_t length, void * priv_data) {
121 struct vm_device * dev = (struct vm_device *)priv_data;
122 struct video_internal * state = (struct video_internal *)dev->private_data;
123 uint_t fb_offset = guest_addr - START_ADDR;
124 uint_t screen_byte_offset = state->screen_offset * BYTES_PER_COL;
125 uint_t screen_length;
127 PrintDebug("Guest address: %p length = %d, fb_offset=%d, screen_offset=%d\n",
128 (void *)guest_addr, length, fb_offset, screen_byte_offset);
130 if (state->passthrough) {
131 memcpy(state->framebuf + fb_offset, V3_VAddr((void *)guest_addr), length);
134 if ((fb_offset >= screen_byte_offset) && (fb_offset < (screen_byte_offset + SCREEN_SIZE))) {
135 uint_t screen_pos = fb_offset - screen_byte_offset;
136 uint_t x = (screen_pos % BYTES_PER_ROW) / BYTES_PER_COL;
137 uint_t y = screen_pos / BYTES_PER_ROW;
138 PrintDebug("Sending Screen update\n");
141 PrintDebug("\tcalling update_screen()\n");
143 /* avoid updates past end of screen */
144 screen_length = SCREEN_SIZE - screen_byte_offset;
145 if (screen_length > length) screen_length = length;
146 state->ops->update_screen(x, y, screen_length, state->private_data);
153 static int video_read_port(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
154 struct vm_device * dev = (struct vm_device *)priv_data;
155 struct video_internal * video_state = (struct video_internal *)dev->private_data;
158 PrintDebug("Video: Read port 0x%x\n", port);
160 if (video_state->passthrough) {
161 passthrough_in(port, dest, length);
169 static int video_write_port(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
170 struct vm_device * dev = (struct vm_device *)priv_data;
171 struct video_internal * video_state = (struct video_internal *)dev->private_data;
174 PrintDebug("Video: write port 0x%x...\n", port);
176 if (video_state->passthrough) {
177 passthrough_out(port, src, length);
185 static int crtc_data_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
186 struct vm_device * dev = (struct vm_device *)priv_data;
187 struct video_internal * video_state = (struct video_internal *)dev->private_data;
188 uint8_t val = *(uint8_t *)src;
189 uint_t index = video_state->crtc_index_reg;
192 PrintError("Invalid write length for port 0x%x\n", port);
196 PrintDebug("Video: write on port 0x%x... (val=0x%x)\n", port, val);
198 video_state->crtc_data_regs[index] = val;
201 case 0x0c: { // scroll high byte
202 uint16_t tmp_val = val;
203 video_state->tmp_screen_offset = ((tmp_val << 8) & 0xff00);
206 case 0x0d: { // Scroll low byte
209 video_state->tmp_screen_offset += val;
210 diff = (video_state->tmp_screen_offset - video_state->screen_offset) / NUM_COLS;
212 // Update the true offset value
213 video_state->screen_offset = video_state->tmp_screen_offset;
214 video_state->tmp_screen_offset = 0;
216 PrintDebug("Scroll lines = %d, new screen offset=%d\n",
217 diff, video_state->screen_offset * BYTES_PER_COL);
219 if (video_state->ops) {
220 if (video_state->ops->scroll(diff, video_state->private_data) == -1) {
221 PrintError("Error sending scroll event\n");
227 case 0x0E: { // Cursor adjustment High byte
228 uint16_t tmp_val = val;
229 video_state->cursor_offset = ((tmp_val << 8) & 0xff00);
233 case 0x0F: { // cursor adjustment low byte
237 video_state->cursor_offset += val;
239 x = video_state->cursor_offset % NUM_COLS;
240 y = (video_state->cursor_offset - video_state->screen_offset) / NUM_COLS;
242 PrintDebug("New Cursor Location; X=%d Y=%d\n", x, y);
244 if (video_state->ops) {
245 if (video_state->ops->update_cursor(x, y, video_state->private_data) == -1) {
246 PrintError("Error updating cursor\n");
257 if (video_state->passthrough) {
258 passthrough_out(port, src, length);
265 static int crtc_index_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
266 struct vm_device * dev = (struct vm_device *)priv_data;
267 struct video_internal * video_state = (struct video_internal *)dev->private_data;
270 PrintError("Invalid write length for crtc index register port: %d (0x%x)\n",
276 video_state->crtc_index_reg = *(uint8_t *)src;
278 // Only do the passthrough IO for the first byte
279 // the second byte will be done in the data register handler
280 if (video_state->passthrough) {
281 passthrough_out(port, src, 1);
285 if (crtc_data_write(core, port + 1, src + 1, length - 1, dev) != (length - 1)) {
286 PrintError("could not handle implicit crtc data write\n");
296 int v3_cons_get_fb(struct vm_device * frontend_dev, uint8_t * dst, uint_t offset, uint_t length) {
297 struct video_internal * state = (struct video_internal *)frontend_dev->private_data;
298 uint_t screen_byte_offset = state->screen_offset * BYTES_PER_COL;
300 PrintDebug("Getting framebuffer for screen; framebuf=%p, screen_offset=%d, offset=%d, length=%d\n",
301 state->framebuf, screen_byte_offset, offset, length);
303 V3_ASSERT(screen_byte_offset <= FRAMEBUF_SIZE - SCREEN_SIZE);
304 V3_ASSERT(offset < SCREEN_SIZE);
305 V3_ASSERT(length <= SCREEN_SIZE);
306 V3_ASSERT(offset + length <= SCREEN_SIZE);
307 memcpy(dst, state->framebuf + screen_byte_offset + offset, length);
314 static int free_device(struct vm_device * dev) {
315 struct video_internal * video_state = (struct video_internal *)dev->private_data;
316 struct v3_vm_info * vm = dev->vm;
318 if (video_state->framebuf_pa) {
319 V3_FreePages((void *)(video_state->framebuf_pa), (FRAMEBUF_SIZE / 4096));
322 v3_unhook_mem(dev->vm, V3_MEM_CORE_ANY, START_ADDR);
324 v3_unhook_io_port(vm, 0x3b0);
325 v3_unhook_io_port(vm, 0x3b1);
326 v3_unhook_io_port(vm, 0x3b2);
327 v3_unhook_io_port(vm, 0x3b3);
328 v3_unhook_io_port(vm, 0x3b4);
329 v3_unhook_io_port(vm, 0x3b5);
330 v3_unhook_io_port(vm, 0x3b6);
331 v3_unhook_io_port(vm, 0x3b7);
332 v3_unhook_io_port(vm, 0x3b8);
333 v3_unhook_io_port(vm, 0x3b9);
334 v3_unhook_io_port(vm, 0x3ba);
335 v3_unhook_io_port(vm, 0x3bb);
336 v3_unhook_io_port(vm, 0x3c0);
337 v3_unhook_io_port(vm, 0x3c1);
338 v3_unhook_io_port(vm, 0x3c2);
339 v3_unhook_io_port(vm, 0x3c3);
340 v3_unhook_io_port(vm, 0x3c4);
341 v3_unhook_io_port(vm, 0x3c5);
342 v3_unhook_io_port(vm, 0x3c6);
343 v3_unhook_io_port(vm, 0x3c7);
344 v3_unhook_io_port(vm, 0x3c8);
345 v3_unhook_io_port(vm, 0x3c9);
346 v3_unhook_io_port(vm, 0x3ca);
347 v3_unhook_io_port(vm, 0x3cb);
348 v3_unhook_io_port(vm, 0x3cc);
349 v3_unhook_io_port(vm, 0x3cd);
350 v3_unhook_io_port(vm, 0x3ce);
351 v3_unhook_io_port(vm, 0x3cf);
352 v3_unhook_io_port(vm, 0x3d0);
353 v3_unhook_io_port(vm, 0x3d1);
354 v3_unhook_io_port(vm, 0x3d2);
355 v3_unhook_io_port(vm, 0x3d3);
356 v3_unhook_io_port(vm, 0x3d4);
357 v3_unhook_io_port(vm, 0x3d5);
358 v3_unhook_io_port(vm, 0x3d6);
359 v3_unhook_io_port(vm, 0x3d7);
360 v3_unhook_io_port(vm, 0x3d8);
361 v3_unhook_io_port(vm, 0x3d9);
362 v3_unhook_io_port(vm, 0x3da);
363 v3_unhook_io_port(vm, 0x3db);
364 v3_unhook_io_port(vm, 0x3dc);
365 v3_unhook_io_port(vm, 0x3dd);
366 v3_unhook_io_port(vm, 0x3de);
367 v3_unhook_io_port(vm, 0x3df);
369 V3_Free(video_state);
375 static struct v3_device_ops dev_ops = {
379 static int cga_init(struct v3_vm_info * vm, v3_cfg_tree_t * cfg) {
380 struct video_internal * video_state = NULL;
381 char * dev_id = v3_cfg_val(cfg, "ID");
382 char * passthrough_str = v3_cfg_val(cfg, "passthrough");
384 PrintDebug("video: init_device\n");
386 video_state = (struct video_internal *)V3_Malloc(sizeof(struct video_internal));
387 memset(video_state, 0, sizeof(struct video_internal));
389 struct vm_device * dev = v3_allocate_device(dev_id, &dev_ops, video_state);
391 if (v3_attach_device(vm, dev) == -1) {
392 PrintError("Could not attach device %s\n", dev_id);
393 V3_Free(video_state);
397 video_state->framebuf_pa = (addr_t)V3_AllocPages(FRAMEBUF_SIZE / 4096);
398 video_state->framebuf = V3_VAddr((void *)(video_state->framebuf_pa));
399 memset(video_state->framebuf, 0, FRAMEBUF_SIZE);
401 PrintDebug("PA of array: %p\n", (void *)(video_state->framebuf_pa));
403 if ((passthrough_str != NULL) &&
404 (strcasecmp(passthrough_str, "enable") == 0)) {;
405 video_state->passthrough = 1;
409 if (video_state->passthrough) {
410 PrintDebug("Enabling CGA Passthrough\n");
411 if (v3_hook_write_mem(vm, V3_MEM_CORE_ANY, START_ADDR, END_ADDR,
412 START_ADDR, &video_write_mem, dev) == -1) {
413 PrintDebug("\n\nVideo Hook failed.\n\n");
416 if (v3_hook_write_mem(vm, V3_MEM_CORE_ANY, START_ADDR, END_ADDR,
417 video_state->framebuf_pa, &video_write_mem, dev) == -1) {
418 PrintDebug("\n\nVideo Hook failed.\n\n");
423 v3_hook_io_port(vm, 0x3b0, &video_read_port, &video_write_port, dev);
424 v3_hook_io_port(vm, 0x3b1, &video_read_port, &video_write_port, dev);
425 v3_hook_io_port(vm, 0x3b2, &video_read_port, &video_write_port, dev);
426 v3_hook_io_port(vm, 0x3b3, &video_read_port, &video_write_port, dev);
427 v3_hook_io_port(vm, 0x3b4, &video_read_port, &video_write_port, dev);
428 v3_hook_io_port(vm, 0x3b5, &video_read_port, &video_write_port, dev);
429 v3_hook_io_port(vm, 0x3b6, &video_read_port, &video_write_port, dev);
430 v3_hook_io_port(vm, 0x3b7, &video_read_port, &video_write_port, dev);
431 v3_hook_io_port(vm, 0x3b8, &video_read_port, &video_write_port, dev);
432 v3_hook_io_port(vm, 0x3b9, &video_read_port, &video_write_port, dev);
433 v3_hook_io_port(vm, 0x3ba, &video_read_port, &video_write_port, dev);
434 v3_hook_io_port(vm, 0x3bb, &video_read_port, &video_write_port, dev);
435 v3_hook_io_port(vm, 0x3c0, &video_read_port, &video_write_port, dev);
436 v3_hook_io_port(vm, 0x3c1, &video_read_port, &video_write_port, dev);
437 v3_hook_io_port(vm, 0x3c2, &video_read_port, &video_write_port, dev);
438 v3_hook_io_port(vm, 0x3c3, &video_read_port, &video_write_port, dev);
439 v3_hook_io_port(vm, 0x3c4, &video_read_port, &video_write_port, dev);
440 v3_hook_io_port(vm, 0x3c5, &video_read_port, &video_write_port, dev);
441 v3_hook_io_port(vm, 0x3c6, &video_read_port, &video_write_port, dev);
442 v3_hook_io_port(vm, 0x3c7, &video_read_port, &video_write_port, dev);
443 v3_hook_io_port(vm, 0x3c8, &video_read_port, &video_write_port, dev);
444 v3_hook_io_port(vm, 0x3c9, &video_read_port, &video_write_port, dev);
445 v3_hook_io_port(vm, 0x3ca, &video_read_port, &video_write_port, dev);
446 v3_hook_io_port(vm, 0x3cb, &video_read_port, &video_write_port, dev);
447 v3_hook_io_port(vm, 0x3cc, &video_read_port, &video_write_port, dev);
448 v3_hook_io_port(vm, 0x3cd, &video_read_port, &video_write_port, dev);
449 v3_hook_io_port(vm, 0x3ce, &video_read_port, &video_write_port, dev);
450 v3_hook_io_port(vm, 0x3cf, &video_read_port, &video_write_port, dev);
451 v3_hook_io_port(vm, 0x3d0, &video_read_port, &video_write_port, dev);
452 v3_hook_io_port(vm, 0x3d1, &video_read_port, &video_write_port, dev);
453 v3_hook_io_port(vm, 0x3d2, &video_read_port, &video_write_port, dev);
454 v3_hook_io_port(vm, 0x3d3, &video_read_port, &video_write_port, dev);
455 v3_hook_io_port(vm, 0x3d4, &video_read_port, &crtc_index_write, dev);
456 v3_hook_io_port(vm, 0x3d5, &video_read_port, &crtc_data_write, dev);
457 v3_hook_io_port(vm, 0x3d6, &video_read_port, &video_write_port, dev);
458 v3_hook_io_port(vm, 0x3d7, &video_read_port, &video_write_port, dev);
459 v3_hook_io_port(vm, 0x3d8, &video_read_port, &video_write_port, dev);
460 v3_hook_io_port(vm, 0x3d9, &video_read_port, &video_write_port, dev);
461 v3_hook_io_port(vm, 0x3da, &video_read_port, &video_write_port, dev);
462 v3_hook_io_port(vm, 0x3db, &video_read_port, &video_write_port, dev);
463 v3_hook_io_port(vm, 0x3dc, &video_read_port, &video_write_port, dev);
464 v3_hook_io_port(vm, 0x3dd, &video_read_port, &video_write_port, dev);
465 v3_hook_io_port(vm, 0x3de, &video_read_port, &video_write_port, dev);
466 v3_hook_io_port(vm, 0x3df, &video_read_port, &video_write_port, dev);
472 device_register("CGA_VIDEO", cga_init);
475 int v3_console_register_cga(struct vm_device * cga_dev, struct v3_console_ops * ops, void * private_data) {
476 struct video_internal * video_state = (struct video_internal *)cga_dev->private_data;
478 video_state->ops = ops;
479 video_state->private_data = private_data;