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
180
kernel/drivers/gpu/virtio_gpu/virtio.h
Normal file
180
kernel/drivers/gpu/virtio_gpu/virtio.h
Normal file
|
|
@ -0,0 +1,180 @@
|
|||
#pragma once
|
||||
|
||||
// virtio 1.0 over PCI — the transport, and virtio-gpu's 2D protocol.
|
||||
//
|
||||
// Next to the driver rather than in include/, because exactly one driver reads
|
||||
// it. When a second virtio device arrives -- virtio-net and virtio-blk are the
|
||||
// obvious ones -- the *transport* half of this belongs in a shared place and
|
||||
// the 2D protocol stays here; splitting it before there is a second caller
|
||||
// would be guessing at where the seam goes.
|
||||
//
|
||||
// Written from the OASIS specification (virtio 1.1, chapters 2, 4.1 and 5.7),
|
||||
// which is a public document with no licence on what you write from it. Same
|
||||
// reasoning as kernel/drivers/xhci.c.
|
||||
//
|
||||
// Why virtio-gpu at all, when there is already a framebuffer: the VBE
|
||||
// framebuffer is a flat block of memory the loader happened to be told about.
|
||||
// It has no mode setting, no notion of a frame being complete, and no way to
|
||||
// ask the host to present anything -- so a compositor drawing into it is
|
||||
// racing the scanout with no way to synchronise. virtio-gpu has resources,
|
||||
// explicit transfer and an explicit flush, which is the model every real GPU
|
||||
// driver has. It is the smallest device that teaches the right shape.
|
||||
|
||||
// --- PCI transport ---------------------------------------------------------
|
||||
|
||||
#define VIRTIO_VENDOR 0x1AF4
|
||||
// Modern (1.0) device IDs are 0x1040 + the virtio device type. GPU is type 16.
|
||||
#define VIRTIO_DEV_GPU 0x1050
|
||||
|
||||
// Vendor-specific PCI capability, which is how a virtio device says where in
|
||||
// its BARs each configuration structure lives.
|
||||
#define PCI_CAP_ID_VNDR 0x09
|
||||
|
||||
#define VIRTIO_PCI_CAP_COMMON_CFG 1
|
||||
#define VIRTIO_PCI_CAP_NOTIFY_CFG 2
|
||||
#define VIRTIO_PCI_CAP_ISR_CFG 3
|
||||
#define VIRTIO_PCI_CAP_DEVICE_CFG 4
|
||||
|
||||
// Offsets within the common configuration structure. Written out rather than
|
||||
// declared as a struct: the fields are little-endian by specification and of
|
||||
// mixed width, and a struct invites the compiler to pad or a caller to forget
|
||||
// that these are MMIO and must be accessed at exactly the stated width.
|
||||
#define VCOMMON_DFEAT_SEL 0x00 // le32
|
||||
#define VCOMMON_DFEAT 0x04 // le32
|
||||
#define VCOMMON_GFEAT_SEL 0x08 // le32
|
||||
#define VCOMMON_GFEAT 0x0C // le32
|
||||
#define VCOMMON_MSIX_CFG 0x10 // le16
|
||||
#define VCOMMON_NUM_QUEUES 0x12 // le16
|
||||
#define VCOMMON_STATUS 0x14 // u8
|
||||
#define VCOMMON_CFG_GEN 0x15 // u8
|
||||
#define VCOMMON_Q_SELECT 0x16 // le16
|
||||
#define VCOMMON_Q_SIZE 0x18 // le16
|
||||
#define VCOMMON_Q_MSIX 0x1A // le16
|
||||
#define VCOMMON_Q_ENABLE 0x1C // le16
|
||||
#define VCOMMON_Q_NOTIFY_OFF 0x1E // le16
|
||||
#define VCOMMON_Q_DESC 0x20 // le64
|
||||
#define VCOMMON_Q_DRIVER 0x28 // le64
|
||||
#define VCOMMON_Q_DEVICE 0x30 // le64
|
||||
|
||||
// device_status bits, set in this order during bring-up.
|
||||
#define VSTATUS_ACK 1
|
||||
#define VSTATUS_DRIVER 2
|
||||
#define VSTATUS_DRIVER_OK 4
|
||||
#define VSTATUS_FEATURES_OK 8
|
||||
#define VSTATUS_FAILED 0x80
|
||||
|
||||
#define VIRTIO_F_VERSION_1 32 // feature bit: this is a 1.0 device
|
||||
|
||||
// --- split virtqueue -------------------------------------------------------
|
||||
|
||||
#define VRING_DESC_F_NEXT 1
|
||||
#define VRING_DESC_F_WRITE 2 // device writes it; i.e. this is our buffer
|
||||
|
||||
struct vring_desc {
|
||||
uint64 addr;
|
||||
uint32 len;
|
||||
uint16 flags;
|
||||
uint16 next;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct vring_avail {
|
||||
uint16 flags;
|
||||
uint16 idx;
|
||||
uint16 ring[];
|
||||
} __attribute__((packed));
|
||||
|
||||
struct vring_used_elem {
|
||||
uint32 id;
|
||||
uint32 len;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct vring_used {
|
||||
uint16 flags;
|
||||
uint16 idx;
|
||||
struct vring_used_elem ring[];
|
||||
} __attribute__((packed));
|
||||
|
||||
// --- virtio-gpu, 2D --------------------------------------------------------
|
||||
|
||||
#define VIRTIO_GPU_CMD_GET_DISPLAY_INFO 0x0100
|
||||
#define VIRTIO_GPU_CMD_RESOURCE_CREATE_2D 0x0101
|
||||
#define VIRTIO_GPU_CMD_RESOURCE_UNREF 0x0102
|
||||
#define VIRTIO_GPU_CMD_SET_SCANOUT 0x0103
|
||||
#define VIRTIO_GPU_CMD_RESOURCE_FLUSH 0x0104
|
||||
#define VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D 0x0105
|
||||
#define VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING 0x0106
|
||||
|
||||
#define VIRTIO_GPU_RESP_OK_NODATA 0x1100
|
||||
#define VIRTIO_GPU_RESP_OK_DISPLAY_INFO 0x1101
|
||||
|
||||
#define VIRTIO_GPU_MAX_SCANOUTS 16
|
||||
|
||||
// B8G8R8X8, which is what a 32-bit little-endian 0x00RRGGBB word looks like in
|
||||
// memory -- the same layout vga.c already draws into, so a framebuffer can be
|
||||
// handed over without a conversion pass.
|
||||
#define VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM 2
|
||||
|
||||
struct virtio_gpu_ctrl_hdr {
|
||||
uint32 type;
|
||||
uint32 flags;
|
||||
uint64 fence_id;
|
||||
uint32 ctx_id;
|
||||
uint32 padding;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_rect {
|
||||
uint32 x, y, width, height;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_display_one {
|
||||
struct virtio_gpu_rect r;
|
||||
uint32 enabled;
|
||||
uint32 flags;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_resp_display_info {
|
||||
struct virtio_gpu_ctrl_hdr hdr;
|
||||
struct virtio_gpu_display_one pmodes[VIRTIO_GPU_MAX_SCANOUTS];
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_resource_create_2d {
|
||||
struct virtio_gpu_ctrl_hdr hdr;
|
||||
uint32 resource_id;
|
||||
uint32 format;
|
||||
uint32 width;
|
||||
uint32 height;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_mem_entry {
|
||||
uint64 addr;
|
||||
uint32 length;
|
||||
uint32 padding;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_resource_attach_backing {
|
||||
struct virtio_gpu_ctrl_hdr hdr;
|
||||
uint32 resource_id;
|
||||
uint32 nr_entries;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_set_scanout {
|
||||
struct virtio_gpu_ctrl_hdr hdr;
|
||||
struct virtio_gpu_rect r;
|
||||
uint32 scanout_id;
|
||||
uint32 resource_id;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_transfer_to_host_2d {
|
||||
struct virtio_gpu_ctrl_hdr hdr;
|
||||
struct virtio_gpu_rect r;
|
||||
uint64 offset;
|
||||
uint32 resource_id;
|
||||
uint32 padding;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_resource_flush {
|
||||
struct virtio_gpu_ctrl_hdr hdr;
|
||||
struct virtio_gpu_rect r;
|
||||
uint32 resource_id;
|
||||
uint32 padding;
|
||||
} __attribute__((packed));
|
||||
|
|
@ -59,9 +59,26 @@ struct vgpu {
|
|||
void *fb; // the framebuffer we scan out from
|
||||
uint32 fb_bytes;
|
||||
int ready;
|
||||
// Which PCI device this instance drives, so attached() can match the device
|
||||
// the bus publishes against the instance probe() set up.
|
||||
struct pci_dev *pdev;
|
||||
};
|
||||
|
||||
static struct vgpu gpu;
|
||||
// More than one, because two display adapters in a machine is ordinary --
|
||||
// integrated plus discrete on real hardware, two -device virtio-gpu-pci under
|
||||
// QEMU -- and this driver used to refuse the second outright.
|
||||
#define VGPU_MAX 2
|
||||
|
||||
static struct vgpu gpus[VGPU_MAX];
|
||||
|
||||
// The instance behind a device, or 0. Every op goes through this rather than a
|
||||
// file-static, which is what makes the second adapter possible at all. See
|
||||
// include/netdev.h and the e1000 for the same arrangement on the network side.
|
||||
static struct vgpu *
|
||||
vgpu_of(struct device *d)
|
||||
{
|
||||
return d ? (struct vgpu *)d->priv : 0;
|
||||
}
|
||||
|
||||
// --- MMIO accessors --------------------------------------------------------
|
||||
//
|
||||
|
|
@ -309,51 +326,61 @@ setup_scanout(struct vgpu *g)
|
|||
static void
|
||||
vgpu_mode(struct device *d, struct display_mode *m)
|
||||
{
|
||||
m->width = gpu.width;
|
||||
m->height = gpu.height;
|
||||
struct vgpu *g = vgpu_of(d);
|
||||
|
||||
if (!g)
|
||||
return;
|
||||
m->width = g->width;
|
||||
m->height = g->height;
|
||||
m->bpp = 32;
|
||||
m->stride = (uint32)gpu.width * 4;
|
||||
m->stride = (uint32)g->width * 4;
|
||||
}
|
||||
|
||||
static void *
|
||||
vgpu_acquire(struct device *d, uint32 *stride_out)
|
||||
{
|
||||
struct vgpu *g = vgpu_of(d);
|
||||
|
||||
if (!g)
|
||||
return 0;
|
||||
if (stride_out)
|
||||
*stride_out = (uint32)gpu.width * 4;
|
||||
*stride_out = (uint32)g->width * 4;
|
||||
// No separate back buffer: the guest-side framebuffer already *is* one. The
|
||||
// host cannot see it until TRANSFER_TO_HOST_2D, so drawing into it is
|
||||
// inherently off-screen -- which is the whole reason this device is better to
|
||||
// composite against than a raw VBE aperture.
|
||||
return gpu.ready ? gpu.fb : 0;
|
||||
return g->ready ? g->fb : 0;
|
||||
}
|
||||
|
||||
static void
|
||||
vgpu_present(struct device *d, int x, int y, int w, int h)
|
||||
{
|
||||
if (!gpu.ready)
|
||||
struct vgpu *g = vgpu_of(d);
|
||||
|
||||
if (!g || !g->ready)
|
||||
return;
|
||||
if (x < 0) { w += x; x = 0; }
|
||||
if (y < 0) { h += y; y = 0; }
|
||||
if (x + w > gpu.width) w = gpu.width - x;
|
||||
if (y + h > gpu.height) h = gpu.height - y;
|
||||
if (x + w > g->width) w = g->width - x;
|
||||
if (y + h > g->height) h = g->height - y;
|
||||
if (w <= 0 || h <= 0)
|
||||
return;
|
||||
|
||||
{
|
||||
struct virtio_gpu_transfer_to_host_2d *t = gpu.cmd;
|
||||
struct virtio_gpu_transfer_to_host_2d *t = g->cmd;
|
||||
hdr_init(t, VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D);
|
||||
t->r.x = x; t->r.y = y; t->r.width = w; t->r.height = h;
|
||||
t->offset = (uint64)y * gpu.width * 4 + (uint64)x * 4;
|
||||
t->offset = (uint64)y * g->width * 4 + (uint64)x * 4;
|
||||
t->resource_id = 1;
|
||||
if (cmd(&gpu, sizeof(*t), sizeof(struct virtio_gpu_ctrl_hdr)) != 0)
|
||||
if (cmd(g, sizeof(*t), sizeof(struct virtio_gpu_ctrl_hdr)) != 0)
|
||||
return;
|
||||
}
|
||||
{
|
||||
struct virtio_gpu_resource_flush *f = gpu.cmd;
|
||||
struct virtio_gpu_resource_flush *f = g->cmd;
|
||||
hdr_init(f, VIRTIO_GPU_CMD_RESOURCE_FLUSH);
|
||||
f->r.x = x; f->r.y = y; f->r.width = w; f->r.height = h;
|
||||
f->resource_id = 1;
|
||||
cmd(&gpu, sizeof(*f), sizeof(struct virtio_gpu_ctrl_hdr));
|
||||
cmd(g, sizeof(*f), sizeof(struct virtio_gpu_ctrl_hdr));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -372,10 +399,16 @@ const struct display_ops virtio_gpu_display_ops = {
|
|||
static int
|
||||
vgpu_probe(struct pci_dev *d)
|
||||
{
|
||||
struct vgpu *g = &gpu;
|
||||
struct vgpu *g = 0;
|
||||
|
||||
if (g->ready)
|
||||
return -1; // one display is enough for now
|
||||
for (int i = 0; i < VGPU_MAX; i++)
|
||||
if (!gpus[i].ready) {
|
||||
g = &gpus[i];
|
||||
break;
|
||||
}
|
||||
if (!g)
|
||||
return -1; // every slot already drives an adapter
|
||||
g->pdev = d;
|
||||
|
||||
pci_enable(d, 0x0006); // memory space + bus master
|
||||
|
||||
|
|
@ -443,9 +476,23 @@ static const struct pci_match virtio_gpu_match[] = {
|
|||
{ 0, 0, 0, 0 },
|
||||
};
|
||||
|
||||
// Hang the instance on the device the bus has just published. probe() runs
|
||||
// before device_add(), so there is nothing to attach it to in there -- see the
|
||||
// comment on `attached` in include/pci.h.
|
||||
static void
|
||||
vgpu_attached(struct pci_dev *d, struct device *dev)
|
||||
{
|
||||
for (int i = 0; i < VGPU_MAX; i++)
|
||||
if (gpus[i].ready && gpus[i].pdev == d) {
|
||||
dev->priv = &gpus[i];
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
const struct pci_driver virtio_gpu_driver = {
|
||||
.name = "virtio-gpu",
|
||||
.match = virtio_gpu_match,
|
||||
.ops = &virtio_gpu_display_ops,
|
||||
.probe = vgpu_probe,
|
||||
.attached = vgpu_attached,
|
||||
};
|
||||
|
|
|
|||
Loading…
Reference in a new issue