gfx: the console and the crash screen stop drawing on a driver by name
Same disease as the network stack, one subsystem over. kernel/dev/vga.c
was three things wearing one name: the owner of the framebuffer, a
bitmap drawing library, and the text console. Only the first is a
driver, and because they shared a file they shared a prefix -- so
panic.c drew the crash screen with vga_fill_rect, console.c printed with
vga_putc, /dev/fb0 handed out vga_fb_phys, and every one of those files
named a display driver it had no business knowing about.
Split three ways:
- kernel/drivers/gpu/vga/vga_fb.c owns the VBE framebuffer -- the mode
the loader programmed and handed over, the aperture, and the display
class vtable. It is a driver and now lives with the driver that
finds the card on the bus.
- kernel/dev/gfx.c draws: pixels, shapes, glyphs, the cursor, scroll,
the ANSI erase operations. It names no driver. The framebuffer
arrives through gfx_attach_scanout(), so a driver publishes what it
owns and this file draws on it without knowing what it is.
- include/gfx.h is the interface, and says why it is deliberately not
the display class: that one is about frames -- acquire, present,
vblank -- and the crash screen has to work when nothing else does.
main() no longer calls a display driver. platform_register_devices()
takes the framebuffer address and brings up whatever owns it, which is
where driver names belong; kernel/drivers/registry.c is the file whose
entire job is naming every driver in the kernel.
virtio-gpu got the e1000 treatment as well: instances in an array, the
instance hung on dev->priv by an `attached` hook, and every op reading
it rather than a file-static. It refused the second adapter outright
before, which is not hypothetical -- integrated plus discrete is an
ordinary laptop. The VGA driver deliberately has no such hook, and says
so: there is one framebuffer the loader programmed however many
VGA-class controllers the bus turns up, and a second one publishing the
same scanout is the truth rather than a bug.
Private headers moved next to their drivers: include/virtio.h and
include/xhci.h each had exactly one includer. include/ is for headers
the rest of the kernel needs.
Deleted rather than moved: consoleinit() programmed the sixteen ANSI
colours into the VGA DAC and disabled text-mode blink, by writing ports
0x3C0-0x3C9 from the console. The comment three lines above the colour
table already said this does nothing in a 32bpp linear mode -- there is
no palette to index -- so it was both dead and in the wrong file.
Verified, and this is a refactor so the evidence is that nothing moved:
- bootcheck -Fb -Net: 59 [ok], no failures. That covers the console
through every command, /dev/fb0's geometry, writing pixels through
write() and mapping the framebuffer through mmap.
- make crashshot: the crash screen renders exactly as before --
shapes, glyphs, logo and QR code -- which is the whole of gfx.c
exercised at once, in a panic, with the scanout attached by a driver.
- make schcom-test: five pixel assertions from the host oracle still
pass, so the display class and the compositor above it are unmoved.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Nexoniarz
parent
20cc673a41
commit
817d666068
22 changed files with 942 additions and 752 deletions
|
|
@ -13,6 +13,7 @@
|
|||
|
||||
#include "types.h"
|
||||
#include "defs.h"
|
||||
#include "gfx.h"
|
||||
#include "param.h"
|
||||
#include "mmu.h"
|
||||
#include "proc.h"
|
||||
|
|
@ -35,7 +36,7 @@ chan(struct fb_bitfield *f, unsigned int offset, unsigned int length)
|
|||
f->msb_right = 0;
|
||||
}
|
||||
|
||||
// Pixel layout for the depths vga_draw_pixel knows how to write. Keeping the
|
||||
// Pixel layout for the depths gfx_draw_pixel knows how to write. Keeping the
|
||||
// two in step matters: this is the kernel telling userspace how to build a
|
||||
// pixel, and if it disagrees with how the kernel builds one, every colour
|
||||
// drawn by a program is wrong in a way that looks like a hardware fault.
|
||||
|
|
@ -52,7 +53,7 @@ pixel_format(struct fb_var_screeninfo *v, unsigned int bpp)
|
|||
chan(&v->transp, 0, 0);
|
||||
break;
|
||||
case 16:
|
||||
// RGB565, matching the packing vga_draw_pixel does for this depth.
|
||||
// RGB565, matching the packing gfx_draw_pixel does for this depth.
|
||||
chan(&v->red, 11, 5); chan(&v->green, 5, 6); chan(&v->blue, 0, 5);
|
||||
chan(&v->transp, 0, 0);
|
||||
break;
|
||||
|
|
@ -66,8 +67,8 @@ pixel_format(struct fb_var_screeninfo *v, unsigned int bpp)
|
|||
int
|
||||
fbread(struct inode *ip, uint64 off, char *dst, int n)
|
||||
{
|
||||
volatile uchar *fb = vga_fb_ptr();
|
||||
uint64 size = vga_fb_size();
|
||||
volatile uchar *fb = gfx_fb_ptr();
|
||||
uint64 size = gfx_fb_size();
|
||||
|
||||
if (!fb)
|
||||
return -ENODEV;
|
||||
|
|
@ -100,8 +101,8 @@ fb_mapped(void)
|
|||
int
|
||||
fbwrite(struct inode *ip, uint64 off, char *src, int n)
|
||||
{
|
||||
volatile uchar *fb = vga_fb_ptr();
|
||||
uint64 size = vga_fb_size();
|
||||
volatile uchar *fb = gfx_fb_ptr();
|
||||
uint64 size = gfx_fb_size();
|
||||
|
||||
if (!fb)
|
||||
return -ENODEV;
|
||||
|
|
@ -137,7 +138,7 @@ fbclose(struct inode *ip)
|
|||
// indistinguishable from a bug -- and this is the only place in the system
|
||||
// that wipes the display without being asked to.
|
||||
cprintf("fb0: released by pid %d, console restored\n", myproc() ? myproc()->pid : -1);
|
||||
vga_screen_reset();
|
||||
gfx_screen_reset();
|
||||
}
|
||||
|
||||
// FBIO* handling, called from sys_ioctl once it has established that the fd
|
||||
|
|
@ -151,10 +152,10 @@ fb_ioctl(int request, addr_t arg)
|
|||
{
|
||||
int w, h;
|
||||
|
||||
if (!vga_fb_ptr())
|
||||
if (!gfx_fb_ptr())
|
||||
return -ENODEV;
|
||||
|
||||
vga_dims(&w, &h);
|
||||
gfx_dims(&w, &h);
|
||||
|
||||
switch (request) {
|
||||
case FBIOGET_VSCREENINFO: {
|
||||
|
|
@ -165,7 +166,7 @@ fb_ioctl(int request, addr_t arg)
|
|||
memset(v, 0, sizeof(*v));
|
||||
v->xres = v->xres_virtual = (unsigned int)w;
|
||||
v->yres = v->yres_virtual = (unsigned int)h;
|
||||
v->bits_per_pixel = vga_fb_bpp();
|
||||
v->bits_per_pixel = gfx_fb_bpp();
|
||||
v->activate = FB_ACTIVATE_NOW;
|
||||
pixel_format(v, v->bits_per_pixel);
|
||||
// height/width (physical millimetres) and every timing field stay zero:
|
||||
|
|
@ -180,11 +181,11 @@ fb_ioctl(int request, addr_t arg)
|
|||
return -EFAULT;
|
||||
memset(f, 0, sizeof(*f));
|
||||
safestrcpy(f->id, "schosfb", sizeof(f->id));
|
||||
f->smem_start = (unsigned long)vga_fb_phys();
|
||||
f->smem_len = (unsigned int)vga_fb_size();
|
||||
f->smem_start = (unsigned long)gfx_fb_phys();
|
||||
f->smem_len = (unsigned int)gfx_fb_size();
|
||||
f->type = FB_TYPE_PACKED_PIXELS;
|
||||
f->visual = FB_VISUAL_TRUECOLOR;
|
||||
f->line_length = vga_fb_stride();
|
||||
f->line_length = gfx_fb_stride();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
444
kernel/dev/gfx.c
Normal file
444
kernel/dev/gfx.c
Normal file
|
|
@ -0,0 +1,444 @@
|
|||
// Drawing and the text console, on whatever display is bound. See include/gfx.h
|
||||
// for why this is not a driver and does not name one.
|
||||
//
|
||||
// It was kernel/dev/vga.c, and the name was the problem: panic.c called
|
||||
// gfx_fill_rect, console.c called gfx_putc, /dev/fb0 called gfx_fb_phys. None
|
||||
// of this code is VGA-specific -- it is bitmap drawing over a linear
|
||||
// framebuffer -- and the one part that genuinely was is now the driver, in
|
||||
// kernel/drivers/gpu/vga/.
|
||||
//
|
||||
// The framebuffer arrives through gfx_attach_scanout() rather than being read
|
||||
// out of the boot block here. That is the whole of the inversion: a driver
|
||||
// publishes what it owns, and this file draws on it without knowing what it is.
|
||||
|
||||
#include "types.h"
|
||||
#include "x86.h"
|
||||
#include "memlayout.h"
|
||||
#include "defs.h"
|
||||
#include "theme.h"
|
||||
#include "font.h"
|
||||
#include "logo.h"
|
||||
#include "device.h"
|
||||
#include "display.h"
|
||||
#include "gfx.h"
|
||||
|
||||
#define BACKSPACE 0x100
|
||||
#define CHAR_HEIGHT 16
|
||||
#define CHAR_WIDTH 8
|
||||
#define COLOR_BG SCH_BG
|
||||
|
||||
// The scanout, as published by whichever driver owns the display. Zeroed until
|
||||
// one does, and every entry point checks `fb` before touching memory -- a
|
||||
// kernel that panics before any display driver has run still has to be able to
|
||||
// call in here and do nothing gracefully.
|
||||
static struct fb_info scanout;
|
||||
static volatile uchar *fb;
|
||||
|
||||
static int cursor_x = 0;
|
||||
static int cursor_y = 0;
|
||||
// Current fill color for glyph backgrounds, backspace erase, and scroll --
|
||||
// normally COLOR_BG, but panic() switches this to paint the whole console a
|
||||
// solid color (e.g. PSOGM's purple) instead of leaving cream-colored boxes
|
||||
// around each character.
|
||||
static uint32 gfx_bg = COLOR_BG;
|
||||
|
||||
void
|
||||
gfx_attach_scanout(const struct fb_info *info)
|
||||
{
|
||||
scanout = *info;
|
||||
fb = info->ptr;
|
||||
}
|
||||
|
||||
const struct fb_info *
|
||||
gfx_scanout(void)
|
||||
{
|
||||
return fb ? &scanout : 0;
|
||||
}
|
||||
|
||||
void
|
||||
gfx_set_bg(uint32 color)
|
||||
{
|
||||
gfx_bg = color;
|
||||
}
|
||||
|
||||
|
||||
// The mode that was actually set. Exported because the resolution is chosen at
|
||||
// boot now (press R -- see boot/bios/stage2.S), so nothing above may assume it.
|
||||
uint32
|
||||
gfx_width(void)
|
||||
{
|
||||
return scanout.width;
|
||||
}
|
||||
|
||||
uint32
|
||||
gfx_height(void)
|
||||
{
|
||||
return scanout.height;
|
||||
}
|
||||
|
||||
void
|
||||
gfx_draw_pixel(int x, int y, uint32 color)
|
||||
{
|
||||
if (!fb || x < 0 || x >= scanout.width || y < 0 || y >= scanout.height)
|
||||
return;
|
||||
|
||||
uint32 offset = (y * scanout.stride) + (x * (scanout.bpp / 8));
|
||||
|
||||
if (scanout.bpp == 32) {
|
||||
*(volatile uint32*)(fb + offset) = color;
|
||||
} else if (scanout.bpp == 24) {
|
||||
fb[offset] = color & 0xFF;
|
||||
fb[offset + 1] = (color >> 8) & 0xFF;
|
||||
fb[offset + 2] = (color >> 16) & 0xFF;
|
||||
} else if (scanout.bpp == 16) {
|
||||
uint16 c16 = (((color >> 19) & 0x1F) << 11) | (((color >> 10) & 0x3F) << 5) | ((color >> 3) & 0x1F);
|
||||
*(volatile uint16*)(fb + offset) = c16;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gfx_clear(uint32 color)
|
||||
{
|
||||
for (int y = 0; y < scanout.height; y++) {
|
||||
for (int x = 0; x < scanout.width; x++) {
|
||||
gfx_draw_pixel(x, y, color);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gfx_draw_char(int x, int y, uchar c, uint32 color)
|
||||
{
|
||||
// No `c > 127` rejection any more: font_data holds 256 Latin-1 glyphs, and
|
||||
// a uchar cannot index past them.
|
||||
if (!fb) return;
|
||||
|
||||
for (int row = 0; row < CHAR_HEIGHT; row++) {
|
||||
uchar row_data = font_data[c][row];
|
||||
for (int col = 0; col < CHAR_WIDTH; col++) {
|
||||
if (row_data & (0x80 >> col)) {
|
||||
gfx_draw_pixel(x + col, y + row, color);
|
||||
} else {
|
||||
gfx_draw_pixel(x + col, y + row, gfx_bg);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gfx_puts(int x, int y, char *s, uint32 color)
|
||||
{
|
||||
while (*s) {
|
||||
gfx_putc((uchar)*s, color);
|
||||
s++;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gfx_putc(int c, uint32 color)
|
||||
{
|
||||
if (!fb) return;
|
||||
|
||||
if (c == BACKSPACE || c == 0x08 || c == '\b' || c == 127) {
|
||||
if (cursor_x >= CHAR_WIDTH) {
|
||||
cursor_x -= CHAR_WIDTH;
|
||||
for (int i = 0; i < CHAR_HEIGHT; i++) {
|
||||
for (int j = 0; j < CHAR_WIDTH; j++) {
|
||||
gfx_draw_pixel(cursor_x + j, cursor_y + i, gfx_bg);
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (c == '\n') {
|
||||
cursor_x = 0;
|
||||
cursor_y += CHAR_HEIGHT;
|
||||
} else if (c == '\r') {
|
||||
cursor_x = 0;
|
||||
} else if (c == '\t') {
|
||||
// Advance to the next multiple of eight columns, erasing as it goes so a
|
||||
// tab overwrites rather than skipping over stale characters.
|
||||
//
|
||||
// There was no tab case at all, so '\t' fell through to gfx_draw_char and
|
||||
// was drawn as glyph 9 -- which in CP437 is a hollow circle. Pressing Tab
|
||||
// printed a circle. Same for every other control character: the font has
|
||||
// a picture for each of them, and none of those pictures is what the
|
||||
// character means.
|
||||
int col = cursor_x / CHAR_WIDTH;
|
||||
int stop = (col + 8) & ~7;
|
||||
while (col < stop && cursor_x < (int)scanout.width) {
|
||||
for (int i = 0; i < CHAR_HEIGHT; i++)
|
||||
for (int j = 0; j < CHAR_WIDTH; j++)
|
||||
gfx_draw_pixel(cursor_x + j, cursor_y + i, gfx_bg);
|
||||
cursor_x += CHAR_WIDTH;
|
||||
col++;
|
||||
}
|
||||
} else if (c < 32) {
|
||||
return; // any other control character: not a glyph
|
||||
} else {
|
||||
gfx_draw_char(cursor_x, cursor_y, (uchar)c, color);
|
||||
cursor_x += CHAR_WIDTH;
|
||||
}
|
||||
|
||||
if (cursor_x >= scanout.width) {
|
||||
cursor_x = 0;
|
||||
cursor_y += CHAR_HEIGHT;
|
||||
}
|
||||
|
||||
if (cursor_y > (scanout.height - CHAR_HEIGHT)) {
|
||||
uint32 line_size = scanout.stride * CHAR_HEIGHT;
|
||||
uint32 total_size = scanout.stride * scanout.height;
|
||||
uint32 copy_size = total_size - line_size;
|
||||
|
||||
memmove((void*)fb, (void*)(fb + line_size), copy_size);
|
||||
|
||||
for (int y = scanout.height - CHAR_HEIGHT; y < scanout.height; y++) {
|
||||
for (int x = 0; x < scanout.width; x++) {
|
||||
gfx_draw_pixel(x, y, gfx_bg);
|
||||
}
|
||||
}
|
||||
cursor_y = scanout.height - CHAR_HEIGHT;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gfx_screen_reset(void)
|
||||
{
|
||||
gfx_bg = COLOR_BG;
|
||||
gfx_clear(COLOR_BG);
|
||||
cursor_x = 0;
|
||||
cursor_y = 0;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Drawing primitives for the crash screen */
|
||||
/* */
|
||||
/* The crash screen lays itself out rather than printing, which needs */
|
||||
/* two things the console never did: filled shapes, and text at an */
|
||||
/* absolute position that leaves the cursor alone. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
int
|
||||
gfx_ready(void)
|
||||
{
|
||||
return fb != 0;
|
||||
}
|
||||
|
||||
void
|
||||
gfx_dims(int *w, int *h)
|
||||
{
|
||||
if (w) *w = (int)scanout.width;
|
||||
if (h) *h = (int)scanout.height;
|
||||
}
|
||||
|
||||
int gfx_char_w(void) { return CHAR_WIDTH; }
|
||||
int gfx_char_h(void) { return CHAR_HEIGHT; }
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Framebuffer geometry */
|
||||
/* */
|
||||
/* Whatever the attached scanout says, rather than anything read from */
|
||||
/* the boot block here -- the driver that owns the display is the only */
|
||||
/* thing that knows where the pixels are. See kernel/dev/fb.c for the */
|
||||
/* device these back. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
uint64 gfx_fb_phys(void) { return scanout.phys; }
|
||||
|
||||
// Bytes of framebuffer, measured in scanlines rather than as
|
||||
// width * height * bpp/8 -- the two differ whenever the card pads its rows,
|
||||
// and it is the stride that says how far apart two rows really are.
|
||||
uint64 gfx_fb_size(void)
|
||||
{
|
||||
if (!fb)
|
||||
return 0;
|
||||
return (uint64)scanout.stride * (uint64)scanout.height;
|
||||
}
|
||||
|
||||
uint32 gfx_fb_stride(void) { return scanout.stride; }
|
||||
uint32 gfx_fb_bpp(void) { return scanout.bpp; }
|
||||
|
||||
volatile uchar *gfx_fb_ptr(void) { return fb; }
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Cursor addressing and erasing */
|
||||
/* */
|
||||
/* What an ANSI escape parser needs and gfx_putc alone cannot give it: */
|
||||
/* the ability to put the cursor somewhere specific and to erase a */
|
||||
/* region without writing spaces over it. See kernel/core/console.c. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
int gfx_cols(void) { return scanout.width ? (int)(scanout.width / CHAR_WIDTH) : 0; }
|
||||
int gfx_rows(void) { return scanout.height ? (int)(scanout.height / CHAR_HEIGHT) : 0; }
|
||||
|
||||
void
|
||||
gfx_cursor_get(int *col, int *row)
|
||||
{
|
||||
if (col) *col = cursor_x / CHAR_WIDTH;
|
||||
if (row) *row = cursor_y / CHAR_HEIGHT;
|
||||
}
|
||||
|
||||
// Clamped rather than validated: an escape sequence is untrusted input that
|
||||
// arrives from any program that can write to the terminal, and "CUP to row
|
||||
// 9999" should put the cursor on the last row, not off the end of the
|
||||
// framebuffer.
|
||||
void
|
||||
gfx_cursor_set(int col, int row)
|
||||
{
|
||||
int maxc = gfx_cols(), maxr = gfx_rows();
|
||||
|
||||
if (maxc <= 0 || maxr <= 0)
|
||||
return;
|
||||
if (col < 0) col = 0;
|
||||
if (row < 0) row = 0;
|
||||
if (col >= maxc) col = maxc - 1;
|
||||
if (row >= maxr) row = maxr - 1;
|
||||
|
||||
cursor_x = col * CHAR_WIDTH;
|
||||
cursor_y = row * CHAR_HEIGHT;
|
||||
}
|
||||
|
||||
// Fill a run of character cells with the background colour.
|
||||
static void
|
||||
erase_cells(int col, int row, int count)
|
||||
{
|
||||
int maxc = gfx_cols();
|
||||
|
||||
while (count-- > 0) {
|
||||
int x = col * CHAR_WIDTH, y = row * CHAR_HEIGHT;
|
||||
for (int i = 0; i < CHAR_HEIGHT; i++)
|
||||
for (int j = 0; j < CHAR_WIDTH; j++)
|
||||
gfx_draw_pixel(x + j, y + i, gfx_bg);
|
||||
if (++col >= maxc) { col = 0; row++; }
|
||||
}
|
||||
}
|
||||
|
||||
// ED -- erase in display. 0: cursor to end, 1: start to cursor, 2: all.
|
||||
void
|
||||
gfx_erase_display(int mode)
|
||||
{
|
||||
int col, row, maxc = gfx_cols(), maxr = gfx_rows();
|
||||
|
||||
gfx_cursor_get(&col, &row);
|
||||
switch (mode) {
|
||||
case 0: erase_cells(col, row, (maxr - row) * maxc - col); break;
|
||||
case 1: erase_cells(0, 0, row * maxc + col + 1); break;
|
||||
default: gfx_clear(gfx_bg); break;
|
||||
}
|
||||
}
|
||||
|
||||
// EL -- erase in line. Same three modes, bounded to the current row.
|
||||
void
|
||||
gfx_erase_line(int mode)
|
||||
{
|
||||
int col, row, maxc = gfx_cols();
|
||||
|
||||
gfx_cursor_get(&col, &row);
|
||||
switch (mode) {
|
||||
case 0: erase_cells(col, row, maxc - col); break;
|
||||
case 1: erase_cells(0, row, col + 1); break;
|
||||
default: erase_cells(0, row, maxc); break;
|
||||
}
|
||||
}
|
||||
|
||||
// Row pointer computed once per row rather than per pixel. The crash screen
|
||||
// paints a solid card behind the QR symbol, and at 8 pixels per module that is
|
||||
// tens of thousands of writes going through gfx_draw_pixel's bounds check and
|
||||
// multiply.
|
||||
void
|
||||
gfx_fill_rect(int x0, int y0, int w, int h, uint32 color)
|
||||
{
|
||||
if (!fb)
|
||||
return;
|
||||
if (x0 < 0) { w += x0; x0 = 0; }
|
||||
if (y0 < 0) { h += y0; y0 = 0; }
|
||||
if (x0 + w > (int)scanout.width) w = (int)scanout.width - x0;
|
||||
if (y0 + h > (int)scanout.height) h = (int)scanout.height - y0;
|
||||
if (w <= 0 || h <= 0)
|
||||
return;
|
||||
|
||||
// Only the 32bpp case gets the fast path; anything else is rare enough that
|
||||
// correctness through gfx_draw_pixel is the better trade.
|
||||
if (scanout.bpp != 32) {
|
||||
for (int y = y0; y < y0 + h; y++)
|
||||
for (int x = x0; x < x0 + w; x++)
|
||||
gfx_draw_pixel(x, y, color);
|
||||
return;
|
||||
}
|
||||
for (int y = y0; y < y0 + h; y++) {
|
||||
volatile uint32 *row = (volatile uint32 *)(fb + y * scanout.stride) + x0;
|
||||
for (int x = 0; x < w; x++)
|
||||
row[x] = color;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gfx_fill_circle(int cx, int cy, int r, uint32 color)
|
||||
{
|
||||
for (int dy = -r; dy <= r; dy++)
|
||||
for (int dx = -r; dx <= r; dx++)
|
||||
if (dx * dx + dy * dy <= r * r)
|
||||
gfx_draw_pixel(cx + dx, cy + dy, color);
|
||||
}
|
||||
|
||||
// Text at an absolute position, leaving the console cursor alone. The crash
|
||||
// screen lays itself out, so gfx_putc's cursor tracking and scrolling are
|
||||
// exactly what it does not want.
|
||||
void
|
||||
gfx_text_at(int x, int y, const char *s, uint32 color)
|
||||
{
|
||||
for (int i = 0; s[i]; i++)
|
||||
gfx_draw_char(x + i * CHAR_WIDTH, y, (uchar)s[i], color);
|
||||
}
|
||||
|
||||
// --- Logo ------------------------------------------------------------------
|
||||
//
|
||||
// The boot splash's logo is drawn by the *loader*, not here -- see splash() in
|
||||
// boot/bios/stage2main.c. It has to be, because the kernel does not reach gfx_init()
|
||||
// until roughly the last 300ms of a 2.8s boot: drawing it here put the logo on
|
||||
// screen for one frame before console_takeover() wiped it, which is worse than
|
||||
// not having one.
|
||||
//
|
||||
// What lives here is the same drawing code against the same mask, for the
|
||||
// things that want the mark *after* boot -- the crash screen, and eventually
|
||||
// whatever schinit shows. Keeping one copy of the compositing logic is why this
|
||||
// is not simply deleted.
|
||||
|
||||
// Blend `fg` over `bg` by coverage a (0..255). Per-channel, integer only: this
|
||||
// runs before any floating point is safe to touch.
|
||||
static uint32
|
||||
blend(uint32 bg, uint32 fg, uint a)
|
||||
{
|
||||
uint32 r = (((fg >> 16) & 0xFF) * a + ((bg >> 16) & 0xFF) * (255 - a)) / 255;
|
||||
uint32 g = (((fg >> 8) & 0xFF) * a + ((bg >> 8) & 0xFF) * (255 - a)) / 255;
|
||||
uint32 b = (((fg ) & 0xFF) * a + ((bg ) & 0xFF) * (255 - a)) / 255;
|
||||
return (r << 16) | (g << 8) | b;
|
||||
}
|
||||
|
||||
void
|
||||
gfx_draw_logo(int x, int y, uint32 color, uint32 bg)
|
||||
{
|
||||
if (!fb)
|
||||
return;
|
||||
for (int dy = 0; dy < LOGO_H; dy++) {
|
||||
for (int dx = 0; dx < LOGO_W; dx++) {
|
||||
uint a = LOGO_INK(dy * LOGO_W + dx);
|
||||
// Skip the background rather than painting it. The mask is a square but
|
||||
// the mark is a circle, so most of it is empty -- and drawing that empty
|
||||
// area in bg would stamp a visible box over whatever is underneath.
|
||||
if (a == 0)
|
||||
continue;
|
||||
gfx_draw_pixel(x + dx, y + dy, a == 255 ? color : blend(bg, color, a));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Centred, for callers that own the whole screen.
|
||||
void
|
||||
gfx_logo_centered(int cy, uint32 color, uint32 bg)
|
||||
{
|
||||
if (!fb || scanout.width < LOGO_W)
|
||||
return;
|
||||
gfx_draw_logo(((int)scanout.width - LOGO_W) / 2, cy - LOGO_H / 2, color, bg);
|
||||
}
|
||||
|
|
@ -1,5 +1,6 @@
|
|||
#include "types.h"
|
||||
#include "defs.h"
|
||||
#include "gfx.h"
|
||||
#include "irq.h"
|
||||
#include "x86.h"
|
||||
#include "traps.h"
|
||||
|
|
@ -71,8 +72,8 @@ mouse_move_locked(int dx, int dy)
|
|||
// It is a boot-time choice now (press R), and at 1280x800 the pointer simply
|
||||
// stopped two thirds of the way across -- which reads as the cursor drifting
|
||||
// away from the host's, rather than as a clamp.
|
||||
int maxx = (int)vga_get_width();
|
||||
int maxy = (int)vga_get_height();
|
||||
int maxx = (int)gfx_width();
|
||||
int maxy = (int)gfx_height();
|
||||
if(maxx <= 0) maxx = 800;
|
||||
if(maxy <= 0) maxy = 600;
|
||||
|
||||
|
|
@ -104,8 +105,8 @@ mouse_inject(int dx, int dy, int buttons)
|
|||
void
|
||||
mouse_set_abs(int x, int y, int buttons)
|
||||
{
|
||||
int maxx = (int)vga_get_width();
|
||||
int maxy = (int)vga_get_height();
|
||||
int maxx = (int)gfx_width();
|
||||
int maxy = (int)gfx_height();
|
||||
if(maxx <= 0) maxx = 800;
|
||||
if(maxy <= 0) maxy = 600;
|
||||
|
||||
|
|
|
|||
569
kernel/dev/vga.c
569
kernel/dev/vga.c
|
|
@ -1,569 +0,0 @@
|
|||
#include "types.h"
|
||||
#include "x86.h"
|
||||
#include "memlayout.h"
|
||||
#include "defs.h"
|
||||
#include "theme.h"
|
||||
#include "font.h"
|
||||
#include "logo.h"
|
||||
#include "device.h"
|
||||
#include "display.h"
|
||||
#include "dma.h"
|
||||
|
||||
#define BACKSPACE 0x100
|
||||
#define CHAR_HEIGHT 16
|
||||
#define CHAR_WIDTH 8
|
||||
#define COLOR_BG SCH_BG
|
||||
|
||||
volatile uchar *vga_mem = 0;
|
||||
// Physical base of the linear framebuffer, as reported by VBE. Every other
|
||||
// part of the kernel that needs to map the framebuffer -- fork's VMA copy,
|
||||
// mmap of /dev/fb0 -- asks for this rather than assuming a value. Three
|
||||
// places used to hardcode 0xfd000000, which is only where QEMU's stdvga
|
||||
// happens to put it.
|
||||
static uint64 vga_phys = 0;
|
||||
static uint32 vga_stride = 0;
|
||||
static uint32 vga_bpp = 0;
|
||||
static uint32 vga_width = 800;
|
||||
static uint32 vga_height = 600;
|
||||
static int cursor_x = 0;
|
||||
static int cursor_y = 0;
|
||||
// Current fill color for glyph backgrounds, backspace erase, and scroll —
|
||||
// normally COLOR_BG, but panic() switches this to paint the whole console
|
||||
// a solid color (e.g. PSOGM's purple) instead of leaving cream-colored boxes
|
||||
// around each character.
|
||||
static uint32 vga_bg = COLOR_BG;
|
||||
|
||||
void
|
||||
vga_set_bg(uint32 color)
|
||||
{
|
||||
vga_bg = color;
|
||||
}
|
||||
|
||||
// Written by boot/bios/stage2.S's VBE call and read by boot/bios/stage2main.c under
|
||||
// the same name (SCHBOOT_VBE_INFO) — not 0x9000, since stage2's own code now
|
||||
// runs up to nearly 0x9000 once the boot-menu/progress-bar logic is
|
||||
// included, which would otherwise clobber a mode info block placed there.
|
||||
#include "schboot.h" /* the hand-off block */
|
||||
|
||||
void
|
||||
vga_init(uint64 phys_addr) {
|
||||
if (phys_addr == 0) {
|
||||
phys_addr = *(uint32*)(P2V(SCHBOOT_VBE_LFB));
|
||||
}
|
||||
vga_mem = (volatile uchar*)P2V(phys_addr);
|
||||
vga_phys = phys_addr;
|
||||
|
||||
vga_stride = *(ushort*)(P2V(SCHBOOT_VBE_STRIDE));
|
||||
vga_width = *(ushort*)(P2V(SCHBOOT_VBE_WIDTH));
|
||||
vga_height = *(ushort*)(P2V(SCHBOOT_VBE_HEIGHT));
|
||||
vga_bpp = *(uchar*)(P2V(SCHBOOT_VBE_BPP));
|
||||
|
||||
if (vga_width == 0) vga_width = 800;
|
||||
if (vga_height == 0) vga_height = 600;
|
||||
if (vga_stride == 0) vga_stride = vga_width * (vga_bpp / 8);
|
||||
|
||||
cprintf("VGA: %dx%d, %d bpp, stride %d, LFB: 0x%x\n", vga_width, vga_height, vga_bpp, vga_stride, (uint32)phys_addr);
|
||||
|
||||
// Deliberately does NOT clear the screen.
|
||||
//
|
||||
// The bootloader has already drawn the splash, and wiping it here is what
|
||||
// produced the old two-act boot: a purple splash for an instant, then an
|
||||
// abrupt cream screen filling with kernel log lines. The splash now stays up
|
||||
// for the whole of boot, and console_takeover() clears it exactly once --
|
||||
// when userspace starts and the display changes owner.
|
||||
}
|
||||
|
||||
// The mode that was actually set. Exported because the resolution is chosen at
|
||||
// boot now (press R -- see boot/bios/stage2.S), so nothing above may assume it.
|
||||
uint32
|
||||
vga_get_width(void)
|
||||
{
|
||||
return vga_width;
|
||||
}
|
||||
|
||||
uint32
|
||||
vga_get_height(void)
|
||||
{
|
||||
return vga_height;
|
||||
}
|
||||
|
||||
void
|
||||
vga_draw_pixel(int x, int y, uint32 color)
|
||||
{
|
||||
if (!vga_mem || x < 0 || x >= vga_width || y < 0 || y >= vga_height)
|
||||
return;
|
||||
|
||||
uint32 offset = (y * vga_stride) + (x * (vga_bpp / 8));
|
||||
|
||||
if (vga_bpp == 32) {
|
||||
*(volatile uint32*)(vga_mem + offset) = color;
|
||||
} else if (vga_bpp == 24) {
|
||||
vga_mem[offset] = color & 0xFF;
|
||||
vga_mem[offset + 1] = (color >> 8) & 0xFF;
|
||||
vga_mem[offset + 2] = (color >> 16) & 0xFF;
|
||||
} else if (vga_bpp == 16) {
|
||||
uint16 c16 = (((color >> 19) & 0x1F) << 11) | (((color >> 10) & 0x3F) << 5) | ((color >> 3) & 0x1F);
|
||||
*(volatile uint16*)(vga_mem + offset) = c16;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
vga_clear(uint32 color)
|
||||
{
|
||||
for (int y = 0; y < vga_height; y++) {
|
||||
for (int x = 0; x < vga_width; x++) {
|
||||
vga_draw_pixel(x, y, color);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
vga_draw_char(int x, int y, uchar c, uint32 color)
|
||||
{
|
||||
// No `c > 127` rejection any more: font_data holds 256 Latin-1 glyphs, and
|
||||
// a uchar cannot index past them.
|
||||
if (!vga_mem) return;
|
||||
|
||||
for (int row = 0; row < CHAR_HEIGHT; row++) {
|
||||
uchar row_data = font_data[c][row];
|
||||
for (int col = 0; col < CHAR_WIDTH; col++) {
|
||||
if (row_data & (0x80 >> col)) {
|
||||
vga_draw_pixel(x + col, y + row, color);
|
||||
} else {
|
||||
vga_draw_pixel(x + col, y + row, vga_bg);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
vga_puts(int x, int y, char *s, uint32 color)
|
||||
{
|
||||
while (*s) {
|
||||
vga_putc((uchar)*s, color);
|
||||
s++;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
vga_putc(int c, uint32 color)
|
||||
{
|
||||
if (!vga_mem) return;
|
||||
|
||||
if (c == BACKSPACE || c == 0x08 || c == '\b' || c == 127) {
|
||||
if (cursor_x >= CHAR_WIDTH) {
|
||||
cursor_x -= CHAR_WIDTH;
|
||||
for (int i = 0; i < CHAR_HEIGHT; i++) {
|
||||
for (int j = 0; j < CHAR_WIDTH; j++) {
|
||||
vga_draw_pixel(cursor_x + j, cursor_y + i, vga_bg);
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (c == '\n') {
|
||||
cursor_x = 0;
|
||||
cursor_y += CHAR_HEIGHT;
|
||||
} else if (c == '\r') {
|
||||
cursor_x = 0;
|
||||
} else if (c == '\t') {
|
||||
// Advance to the next multiple of eight columns, erasing as it goes so a
|
||||
// tab overwrites rather than skipping over stale characters.
|
||||
//
|
||||
// There was no tab case at all, so '\t' fell through to vga_draw_char and
|
||||
// was drawn as glyph 9 -- which in CP437 is a hollow circle. Pressing Tab
|
||||
// printed a circle. Same for every other control character: the font has
|
||||
// a picture for each of them, and none of those pictures is what the
|
||||
// character means.
|
||||
int col = cursor_x / CHAR_WIDTH;
|
||||
int stop = (col + 8) & ~7;
|
||||
while (col < stop && cursor_x < (int)vga_width) {
|
||||
for (int i = 0; i < CHAR_HEIGHT; i++)
|
||||
for (int j = 0; j < CHAR_WIDTH; j++)
|
||||
vga_draw_pixel(cursor_x + j, cursor_y + i, vga_bg);
|
||||
cursor_x += CHAR_WIDTH;
|
||||
col++;
|
||||
}
|
||||
} else if (c < 32) {
|
||||
return; // any other control character: not a glyph
|
||||
} else {
|
||||
vga_draw_char(cursor_x, cursor_y, (uchar)c, color);
|
||||
cursor_x += CHAR_WIDTH;
|
||||
}
|
||||
|
||||
if (cursor_x >= vga_width) {
|
||||
cursor_x = 0;
|
||||
cursor_y += CHAR_HEIGHT;
|
||||
}
|
||||
|
||||
if (cursor_y > (vga_height - CHAR_HEIGHT)) {
|
||||
uint32 line_size = vga_stride * CHAR_HEIGHT;
|
||||
uint32 total_size = vga_stride * vga_height;
|
||||
uint32 copy_size = total_size - line_size;
|
||||
|
||||
memmove((void*)vga_mem, (void*)(vga_mem + line_size), copy_size);
|
||||
|
||||
for (int y = vga_height - CHAR_HEIGHT; y < vga_height; y++) {
|
||||
for (int x = 0; x < vga_width; x++) {
|
||||
vga_draw_pixel(x, y, vga_bg);
|
||||
}
|
||||
}
|
||||
cursor_y = vga_height - CHAR_HEIGHT;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
vga_screen_reset(void)
|
||||
{
|
||||
vga_bg = COLOR_BG;
|
||||
vga_clear(COLOR_BG);
|
||||
cursor_x = 0;
|
||||
cursor_y = 0;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Drawing primitives for the crash screen */
|
||||
/* */
|
||||
/* The crash screen lays itself out rather than printing, which needs */
|
||||
/* two things the console never did: filled shapes, and text at an */
|
||||
/* absolute position that leaves the cursor alone. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
int
|
||||
vga_ready(void)
|
||||
{
|
||||
return vga_mem != 0;
|
||||
}
|
||||
|
||||
void
|
||||
vga_dims(int *w, int *h)
|
||||
{
|
||||
if (w) *w = (int)vga_width;
|
||||
if (h) *h = (int)vga_height;
|
||||
}
|
||||
|
||||
int vga_char_w(void) { return CHAR_WIDTH; }
|
||||
int vga_char_h(void) { return CHAR_HEIGHT; }
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Framebuffer geometry */
|
||||
/* */
|
||||
/* vga.c is the only place that reads the VBE mode info, so it is the */
|
||||
/* only place that knows where the framebuffer actually is. Everything */
|
||||
/* else asks. See kernel/dev/fb.c for the device these back. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
uint64 vga_fb_phys(void) { return vga_phys; }
|
||||
|
||||
// Bytes of framebuffer, measured in scanlines rather than as
|
||||
// width * height * bpp/8 -- the two differ whenever the card pads its rows,
|
||||
// and it is the stride that says how far apart two rows really are.
|
||||
uint64 vga_fb_size(void)
|
||||
{
|
||||
if (!vga_mem)
|
||||
return 0;
|
||||
return (uint64)vga_stride * (uint64)vga_height;
|
||||
}
|
||||
|
||||
uint32 vga_fb_stride(void) { return vga_stride; }
|
||||
uint32 vga_fb_bpp(void) { return vga_bpp; }
|
||||
|
||||
volatile uchar *vga_fb_ptr(void) { return vga_mem; }
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Cursor addressing and erasing */
|
||||
/* */
|
||||
/* What an ANSI escape parser needs and vga_putc alone cannot give it: */
|
||||
/* the ability to put the cursor somewhere specific and to erase a */
|
||||
/* region without writing spaces over it. See kernel/core/console.c. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
int vga_cols(void) { return vga_width ? (int)(vga_width / CHAR_WIDTH) : 0; }
|
||||
int vga_rows(void) { return vga_height ? (int)(vga_height / CHAR_HEIGHT) : 0; }
|
||||
|
||||
void
|
||||
vga_cursor_get(int *col, int *row)
|
||||
{
|
||||
if (col) *col = cursor_x / CHAR_WIDTH;
|
||||
if (row) *row = cursor_y / CHAR_HEIGHT;
|
||||
}
|
||||
|
||||
// Clamped rather than validated: an escape sequence is untrusted input that
|
||||
// arrives from any program that can write to the terminal, and "CUP to row
|
||||
// 9999" should put the cursor on the last row, not off the end of the
|
||||
// framebuffer.
|
||||
void
|
||||
vga_cursor_set(int col, int row)
|
||||
{
|
||||
int maxc = vga_cols(), maxr = vga_rows();
|
||||
|
||||
if (maxc <= 0 || maxr <= 0)
|
||||
return;
|
||||
if (col < 0) col = 0;
|
||||
if (row < 0) row = 0;
|
||||
if (col >= maxc) col = maxc - 1;
|
||||
if (row >= maxr) row = maxr - 1;
|
||||
|
||||
cursor_x = col * CHAR_WIDTH;
|
||||
cursor_y = row * CHAR_HEIGHT;
|
||||
}
|
||||
|
||||
// Fill a run of character cells with the background colour.
|
||||
static void
|
||||
erase_cells(int col, int row, int count)
|
||||
{
|
||||
int maxc = vga_cols();
|
||||
|
||||
while (count-- > 0) {
|
||||
int x = col * CHAR_WIDTH, y = row * CHAR_HEIGHT;
|
||||
for (int i = 0; i < CHAR_HEIGHT; i++)
|
||||
for (int j = 0; j < CHAR_WIDTH; j++)
|
||||
vga_draw_pixel(x + j, y + i, vga_bg);
|
||||
if (++col >= maxc) { col = 0; row++; }
|
||||
}
|
||||
}
|
||||
|
||||
// ED -- erase in display. 0: cursor to end, 1: start to cursor, 2: all.
|
||||
void
|
||||
vga_erase_display(int mode)
|
||||
{
|
||||
int col, row, maxc = vga_cols(), maxr = vga_rows();
|
||||
|
||||
vga_cursor_get(&col, &row);
|
||||
switch (mode) {
|
||||
case 0: erase_cells(col, row, (maxr - row) * maxc - col); break;
|
||||
case 1: erase_cells(0, 0, row * maxc + col + 1); break;
|
||||
default: vga_clear(vga_bg); break;
|
||||
}
|
||||
}
|
||||
|
||||
// EL -- erase in line. Same three modes, bounded to the current row.
|
||||
void
|
||||
vga_erase_line(int mode)
|
||||
{
|
||||
int col, row, maxc = vga_cols();
|
||||
|
||||
vga_cursor_get(&col, &row);
|
||||
switch (mode) {
|
||||
case 0: erase_cells(col, row, maxc - col); break;
|
||||
case 1: erase_cells(0, row, col + 1); break;
|
||||
default: erase_cells(0, row, maxc); break;
|
||||
}
|
||||
}
|
||||
|
||||
// Row pointer computed once per row rather than per pixel. The crash screen
|
||||
// paints a solid card behind the QR symbol, and at 8 pixels per module that is
|
||||
// tens of thousands of writes going through vga_draw_pixel's bounds check and
|
||||
// multiply.
|
||||
void
|
||||
vga_fill_rect(int x0, int y0, int w, int h, uint32 color)
|
||||
{
|
||||
if (!vga_mem)
|
||||
return;
|
||||
if (x0 < 0) { w += x0; x0 = 0; }
|
||||
if (y0 < 0) { h += y0; y0 = 0; }
|
||||
if (x0 + w > (int)vga_width) w = (int)vga_width - x0;
|
||||
if (y0 + h > (int)vga_height) h = (int)vga_height - y0;
|
||||
if (w <= 0 || h <= 0)
|
||||
return;
|
||||
|
||||
// Only the 32bpp case gets the fast path; anything else is rare enough that
|
||||
// correctness through vga_draw_pixel is the better trade.
|
||||
if (vga_bpp != 32) {
|
||||
for (int y = y0; y < y0 + h; y++)
|
||||
for (int x = x0; x < x0 + w; x++)
|
||||
vga_draw_pixel(x, y, color);
|
||||
return;
|
||||
}
|
||||
for (int y = y0; y < y0 + h; y++) {
|
||||
volatile uint32 *row = (volatile uint32 *)(vga_mem + y * vga_stride) + x0;
|
||||
for (int x = 0; x < w; x++)
|
||||
row[x] = color;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
vga_fill_circle(int cx, int cy, int r, uint32 color)
|
||||
{
|
||||
for (int dy = -r; dy <= r; dy++)
|
||||
for (int dx = -r; dx <= r; dx++)
|
||||
if (dx * dx + dy * dy <= r * r)
|
||||
vga_draw_pixel(cx + dx, cy + dy, color);
|
||||
}
|
||||
|
||||
// Text at an absolute position, leaving the console cursor alone. The crash
|
||||
// screen lays itself out, so vga_putc's cursor tracking and scrolling are
|
||||
// exactly what it does not want.
|
||||
void
|
||||
vga_text_at(int x, int y, const char *s, uint32 color)
|
||||
{
|
||||
for (int i = 0; s[i]; i++)
|
||||
vga_draw_char(x + i * CHAR_WIDTH, y, (uchar)s[i], color);
|
||||
}
|
||||
|
||||
// --- Logo ------------------------------------------------------------------
|
||||
//
|
||||
// The boot splash's logo is drawn by the *loader*, not here -- see splash() in
|
||||
// boot/bios/stage2main.c. It has to be, because the kernel does not reach vga_init()
|
||||
// until roughly the last 300ms of a 2.8s boot: drawing it here put the logo on
|
||||
// screen for one frame before console_takeover() wiped it, which is worse than
|
||||
// not having one.
|
||||
//
|
||||
// What lives here is the same drawing code against the same mask, for the
|
||||
// things that want the mark *after* boot -- the crash screen, and eventually
|
||||
// whatever schinit shows. Keeping one copy of the compositing logic is why this
|
||||
// is not simply deleted.
|
||||
|
||||
// Blend `fg` over `bg` by coverage a (0..255). Per-channel, integer only: this
|
||||
// runs before any floating point is safe to touch.
|
||||
static uint32
|
||||
blend(uint32 bg, uint32 fg, uint a)
|
||||
{
|
||||
uint32 r = (((fg >> 16) & 0xFF) * a + ((bg >> 16) & 0xFF) * (255 - a)) / 255;
|
||||
uint32 g = (((fg >> 8) & 0xFF) * a + ((bg >> 8) & 0xFF) * (255 - a)) / 255;
|
||||
uint32 b = (((fg ) & 0xFF) * a + ((bg ) & 0xFF) * (255 - a)) / 255;
|
||||
return (r << 16) | (g << 8) | b;
|
||||
}
|
||||
|
||||
void
|
||||
vga_draw_logo(int x, int y, uint32 color, uint32 bg)
|
||||
{
|
||||
if (!vga_mem)
|
||||
return;
|
||||
for (int dy = 0; dy < LOGO_H; dy++) {
|
||||
for (int dx = 0; dx < LOGO_W; dx++) {
|
||||
uint a = LOGO_INK(dy * LOGO_W + dx);
|
||||
// Skip the background rather than painting it. The mask is a square but
|
||||
// the mark is a circle, so most of it is empty -- and drawing that empty
|
||||
// area in bg would stamp a visible box over whatever is underneath.
|
||||
if (a == 0)
|
||||
continue;
|
||||
vga_draw_pixel(x + dx, y + dy, a == 255 ? color : blend(bg, color, a));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Centred, for callers that own the whole screen.
|
||||
void
|
||||
vga_logo_centered(int cy, uint32 color, uint32 bg)
|
||||
{
|
||||
if (!vga_mem || vga_width < LOGO_W)
|
||||
return;
|
||||
vga_draw_logo(((int)vga_width - LOGO_W) / 2, cy - LOGO_H / 2, color, bg);
|
||||
}
|
||||
|
||||
// --- display class implementation ------------------------------------------
|
||||
//
|
||||
// See include/display.h. This is the VBE linear framebuffer presenting itself
|
||||
// as a generic display, so a compositor can be written against the class and
|
||||
// keep working when virtio-gpu arrives.
|
||||
|
||||
static uchar *back; // shadow buffer in RAM, or 0 if never acquired
|
||||
static uint64 back_bytes;
|
||||
|
||||
static void
|
||||
vga_disp_mode(struct device *d, struct display_mode *m)
|
||||
{
|
||||
m->width = (int)vga_width;
|
||||
m->height = (int)vga_height;
|
||||
m->bpp = (int)vga_bpp;
|
||||
m->stride = vga_stride;
|
||||
}
|
||||
|
||||
static void *
|
||||
vga_disp_acquire(struct device *d, uint32 *stride_out)
|
||||
{
|
||||
if (stride_out)
|
||||
*stride_out = vga_stride;
|
||||
if (back)
|
||||
return back;
|
||||
if (!vga_mem || vga_height == 0 || vga_stride == 0)
|
||||
return 0;
|
||||
|
||||
back_bytes = (uint64)vga_stride * vga_height;
|
||||
|
||||
// From the DMA arena, which is the wrong pool and is used here because it is
|
||||
// the only *physically contiguous* allocator in the kernel -- kalloc hands
|
||||
// out single pages whose neighbours are adjacent only by chance, and a
|
||||
// framebuffer wants one flat span.
|
||||
//
|
||||
// At 800x600x32 this is 1.9 MB of a 4 MB arena meant for device rings, which
|
||||
// is tolerable only because nothing else large lives there yet. The real fix
|
||||
// is a contiguous page allocator, or reserving this at boot from the memory
|
||||
// map -- which is work that belongs with the E820 change in docs/roadmap.md
|
||||
// §3b, since that is what stops the kernel pretending 224 MB exists.
|
||||
//
|
||||
// Allocated on first use rather than at boot on purpose: a machine that never
|
||||
// starts a compositor should not pay two megabytes for one.
|
||||
back = dma_alloc(back_bytes, 4096);
|
||||
if (!back) {
|
||||
cprintf("display: no room for a %d KB back buffer; drawing will tear\n",
|
||||
(int)(back_bytes / 1024));
|
||||
return 0;
|
||||
}
|
||||
memset(back, 0, back_bytes);
|
||||
cprintf("display: %d KB back buffer, double buffered\n",
|
||||
(int)(back_bytes / 1024));
|
||||
return back;
|
||||
}
|
||||
|
||||
// Blit a rectangle from the shadow buffer to the framebuffer.
|
||||
//
|
||||
// Row at a time rather than one memmove for the whole rectangle: only a
|
||||
// full-width rectangle is contiguous in either buffer, and a compositor
|
||||
// updating one window is the case worth being right about.
|
||||
static void
|
||||
vga_disp_present(struct device *d, int x, int y, int w, int h)
|
||||
{
|
||||
if (!back || !vga_mem)
|
||||
return;
|
||||
|
||||
if (x < 0) { w += x; x = 0; }
|
||||
if (y < 0) { h += y; y = 0; }
|
||||
if (x + w > (int)vga_width) w = (int)vga_width - x;
|
||||
if (y + h > (int)vga_height) h = (int)vga_height - y;
|
||||
if (w <= 0 || h <= 0)
|
||||
return;
|
||||
|
||||
int bytes = w * (int)(vga_bpp / 8);
|
||||
uint32 off = (uint32)x * (vga_bpp / 8);
|
||||
for (int row = y; row < y + h; row++)
|
||||
memmove((void *)(vga_mem + row * vga_stride + off),
|
||||
back + row * vga_stride + off, bytes);
|
||||
}
|
||||
|
||||
// Wait for vertical retrace, by polling the VGA input status register.
|
||||
//
|
||||
// Bit 3 of 0x3DA is set during vertical retrace. This is the original 1987 VGA
|
||||
// interface and it still works on everything that emulates a VGA, QEMU's
|
||||
// stdvga included -- VBE's own protected-mode interface for this is optional
|
||||
// and frequently absent, so the old port is the portable answer.
|
||||
//
|
||||
// Two loops, not one: waiting only for the flag to *be* set would return
|
||||
// immediately if a retrace is already in progress, having just missed the
|
||||
// start of it. Waiting for the current one to end and the next to begin is
|
||||
// what actually lands the blit between frames.
|
||||
//
|
||||
// The counters are a deadlock guard. On hardware that never reports retrace
|
||||
// this returns after a bounded spin instead of hanging the caller forever,
|
||||
// which matters because this can be called with the console locked.
|
||||
static void
|
||||
vga_disp_wait_vblank(struct device *d)
|
||||
{
|
||||
int guard;
|
||||
|
||||
for (guard = 0; guard < 1000000; guard++)
|
||||
if (!(inb(0x3DA) & 0x08))
|
||||
break;
|
||||
for (guard = 0; guard < 1000000; guard++)
|
||||
if (inb(0x3DA) & 0x08)
|
||||
break;
|
||||
}
|
||||
|
||||
const struct display_ops vga_display_ops = {
|
||||
.mode = vga_disp_mode,
|
||||
.acquire = vga_disp_acquire,
|
||||
.present = vga_disp_present,
|
||||
.wait_vblank = vga_disp_wait_vblank,
|
||||
};
|
||||
Loading…
Reference in a new issue