RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 03:57:44 +00:00
Code Issues Activity Actions

Kernel: Add support for multiple VirtIO GPU outputs

Browse source 
This creates /dev/fbX devices for each physical output, owned by the
parent VirtIOGPU instance. This allows mapping and setting resolutions
independently for each output.
This commit is contained in:
Tom 2021-06-25 20:44:48 -06:00 • committed by Andreas Kling
parent 708f27ca0e
commit 8749235046
8 changed files with 305 additions and 194 deletions
Download patch file Download diff file Expand all files Collapse all files

161
Kernel/Graphics/VirtIOGPU/VirtIOGPU.cpp
View file

@ -4,7 +4,9 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <Kernel/Graphics/VirtIOGPU/VirtIOFrameBufferDevice.h>
#include <Kernel/Graphics/VirtIOGPU/VirtIOGPU.h>
#include <Kernel/Graphics/VirtIOGPU/VirtIOGPUConsole.h>
#include <LibC/sys/ioctl_numbers.h>
#define DEVICE_EVENTS_READ 0x0
@ -38,23 +40,8 @@ VirtIOGPU::VirtIOGPU(PCI::Address address)
VERIFY(success);
finish_init();
Locker locker(m_operation_lock);
// 1. Get display information using VIRTIO_GPU_CMD_GET_DISPLAY_INFO
// Get display information using VIRTIO_GPU_CMD_GET_DISPLAY_INFO
query_display_information();
// 2. Create BUFFER using VIRTIO_GPU_CMD_RESOURCE_CREATE_2D
m_framebuffer_id = create_2d_resource(m_display_info.rect);
// 3. Attach backing storage using VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING
// FIXME: We really should be trying to allocate a small amount of pages initially, with ensure_backing_storage increasing the backing memory of the region as needed
size_t buffer_length = calculate_framebuffer_size(MAX_VIRTIOGPU_RESOLUTION_WIDTH, MAX_VIRTIOGPU_RESOLUTION_HEIGHT);
m_framebuffer = MM.allocate_kernel_region(page_round_up(buffer_length), "VirtGPU FrameBuffer", Region::Access::Read | Region::Access::Write, AllocationStrategy::AllocateNow);
ensure_backing_storage(*m_framebuffer, buffer_length, m_framebuffer_id);
// 4. Use VIRTIO_GPU_CMD_SET_SCANOUT to link the framebuffer to a display scanout.
set_scanout_resource(m_chosen_scanout.value(), m_framebuffer_id, m_display_info.rect);
// 5. Render our test pattern
draw_ntsc_test_pattern();
// 6. Use VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D to update the host resource from guest memory.
transfer_framebuffer_data_to_host(m_display_info.rect);
// 7. Use VIRTIO_GPU_CMD_RESOURCE_FLUSH to flush the updated resource to the display.
flush_displayed_image(m_display_info.rect);
} else {
VERIFY_NOT_REACHED();
}
@ -64,6 +51,15 @@ VirtIOGPU::~VirtIOGPU()
{
}
void VirtIOGPU::create_framebuffer_devices()
{
for (size_t i = 0; i < min(m_num_scanouts, VIRTIO_GPU_MAX_SCANOUTS); i++) {
auto& scanout = m_scanouts[i];
scanout.framebuffer = adopt_ref(*new VirtIOFrameBufferDevice(*this, i));
scanout.console = Kernel::Graphics::VirtIOGPUConsole::initialize(scanout.framebuffer);
}
}
bool VirtIOGPU::handle_device_config_change()
{
return false;
@ -101,14 +97,19 @@ void VirtIOGPU::query_display_information()
synchronous_virtio_gpu_command(start_of_scratch_space(), sizeof(request), sizeof(response));
for (size_t i = 0; i < VIRTIO_GPU_MAX_SCANOUTS; ++i) {
auto& scanout = response.scanout_modes[i];
if (!scanout.enabled)
continue;
dbgln_if(VIRTIO_DEBUG, "Scanout {}: x: {}, y: {}, width: {}, height: {}", i, scanout.rect.x, scanout.rect.y, scanout.rect.width, scanout.rect.height);
m_display_info = scanout;
m_chosen_scanout = i;
auto& scanout = m_scanouts[i].display_info;
scanout = response.scanout_modes[i];
dbgln_if(VIRTIO_DEBUG, "Scanout {}: enabled: {} x: {}, y: {}, width: {}, height: {}", i, !!scanout.enabled, scanout.rect.x, scanout.rect.y, scanout.rect.width, scanout.rect.height);
if (scanout.enabled && !m_default_scanout.has_value()) {
m_default_scanout = i;
} else if (i < m_num_scanouts) {
// TODO: We should not enable all displays until the first resolution set
scanout.rect.width = 1024;
scanout.rect.height = 768;
scanout.enabled = true;
}
}
VERIFY(m_chosen_scanout.has_value());
VERIFY(m_default_scanout.has_value());
}
VirtIOGPUResourceID VirtIOGPU::create_2d_resource(VirtIOGPURect rect)
@ -157,7 +158,7 @@ void VirtIOGPU::ensure_backing_storage(Region& region, size_t buffer_length, Vir
request.resource_id = resource_id.value();
request.num_entries = num_mem_regions;
for (size_t i = 0; i < num_mem_regions; ++i) {
request.entries[i].address = m_framebuffer->physical_page(i)->paddr().get();
request.entries[i].address = region.physical_page(i)->paddr().get();
request.entries[i].length = PAGE_SIZE;
}
@ -199,71 +200,15 @@ void VirtIOGPU::set_scanout_resource(VirtIOGPUScanoutID scanout, VirtIOGPUResour
dbgln_if(VIRTIO_DEBUG, "VirtIOGPU: Set backing scanout");
}
void VirtIOGPU::draw_ntsc_test_pattern()
{
static constexpr u8 colors[12][4] = {
{ 0xff, 0xff, 0xff, 0xff }, // White
{ 0x00, 0xff, 0xff, 0xff }, // Primary + Composite colors
{ 0xff, 0xff, 0x00, 0xff },
{ 0x00, 0xff, 0x00, 0xff },
{ 0xff, 0x00, 0xff, 0xff },
{ 0x00, 0x00, 0xff, 0xff },
{ 0xff, 0x00, 0x00, 0xff },
{ 0xba, 0x01, 0x5f, 0xff }, // Dark blue
{ 0x8d, 0x3d, 0x00, 0xff }, // Purple
{ 0x22, 0x22, 0x22, 0xff }, // Shades of gray
{ 0x10, 0x10, 0x10, 0xff },
{ 0x00, 0x00, 0x00, 0xff },
};
size_t width = m_display_info.rect.width;
size_t height = m_display_info.rect.height;
u8* data = m_framebuffer->vaddr().as_ptr();
// Draw NTSC test card
for (size_t y = 0; y < height; ++y) {
for (size_t x = 0; x < width; ++x) {
size_t color = 0;
if (3 * y < 2 * height) {
// Top 2/3 of image is 7 vertical stripes of color spectrum
color = (7 * x) / width;
} else if (4 * y < 3 * height) {
// 2/3 mark to 3/4 mark is backwards color spectrum alternating with black
auto segment = (7 * x) / width;
color = segment % 2 ? 10 : 6 - segment;
} else {
if (28 * x < 5 * width) {
color = 8;
} else if (28 * x < 10 * width) {
color = 0;
} else if (28 * x < 15 * width) {
color = 7;
} else if (28 * x < 20 * width) {
color = 10;
} else if (7 * x < 6 * width) {
// Grayscale gradient
color = 26 - ((21 * x) / width);
} else {
// Solid black
color = 10;
}
}
u8* pixel = &data[4 * (y * width + x)];
for (int i = 0; i < 4; ++i) {
pixel[i] = colors[color][i];
}
}
}
dbgln_if(VIRTIO_DEBUG, "Finish drawing the pattern");
}
void VirtIOGPU::transfer_framebuffer_data_to_host(VirtIOGPURect dirty_rect)
void VirtIOGPU::transfer_framebuffer_data_to_host(VirtIOGPUScanoutID scanout, VirtIOGPURect const& dirty_rect, VirtIOGPUResourceID resource_id)
{
VERIFY(m_operation_lock.is_locked());
auto& request = *reinterpret_cast<VirtIOGPUTransferToHost2D*>(m_scratch_space->vaddr().as_ptr());
auto& response = *reinterpret_cast<VirtIOGPUCtrlHeader*>((m_scratch_space->vaddr().offset(sizeof(request)).as_ptr()));
populate_virtio_gpu_request_header(request.header, VirtIOGPUCtrlType::VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D, VIRTIO_GPU_FLAG_FENCE);
request.offset = (dirty_rect.x + (dirty_rect.y * m_display_info.rect.width)) * sizeof(u32);
request.resource_id = m_framebuffer_id.value();
request.offset = (dirty_rect.x + (dirty_rect.y * m_scanouts[scanout.value()].display_info.rect.width)) * sizeof(u32);
request.resource_id = resource_id.value();
request.rect = dirty_rect;
synchronous_virtio_gpu_command(start_of_scratch_space(), sizeof(request), sizeof(response));
@ -271,14 +216,14 @@ void VirtIOGPU::transfer_framebuffer_data_to_host(VirtIOGPURect dirty_rect)
VERIFY(response.type == static_cast<u32>(VirtIOGPUCtrlType::VIRTIO_GPU_RESP_OK_NODATA));
}
void VirtIOGPU::flush_displayed_image(VirtIOGPURect dirty_rect)
void VirtIOGPU::flush_displayed_image(VirtIOGPURect const& dirty_rect, VirtIOGPUResourceID resource_id)
{
VERIFY(m_operation_lock.is_locked());
auto& request = *reinterpret_cast<VirtIOGPUResourceFlush*>(m_scratch_space->vaddr().as_ptr());
auto& response = *reinterpret_cast<VirtIOGPUCtrlHeader*>((m_scratch_space->vaddr().offset(sizeof(request)).as_ptr()));
populate_virtio_gpu_request_header(request.header, VirtIOGPUCtrlType::VIRTIO_GPU_CMD_RESOURCE_FLUSH, VIRTIO_GPU_FLAG_FENCE);
request.resource_id = m_framebuffer_id.value();
request.resource_id = resource_id.value();
request.rect = dirty_rect;
synchronous_virtio_gpu_command(start_of_scratch_space(), sizeof(request), sizeof(response));
@ -311,33 +256,11 @@ void VirtIOGPU::populate_virtio_gpu_request_header(VirtIOGPUCtrlHeader& header,
header.padding = 0;
}
void VirtIOGPU::flush_dirty_window(VirtIOGPURect dirty_rect)
void VirtIOGPU::flush_dirty_window(VirtIOGPUScanoutID scanout, VirtIOGPURect const& dirty_rect, VirtIOGPUResourceID resource_id)
{
Locker locker(m_operation_lock);
transfer_framebuffer_data_to_host(dirty_rect);
flush_displayed_image(dirty_rect);
}
bool VirtIOGPU::try_to_set_resolution(size_t width, size_t height)
{
if (width > MAX_VIRTIOGPU_RESOLUTION_WIDTH && height > MAX_VIRTIOGPU_RESOLUTION_HEIGHT)
return false;
Locker locker(m_operation_lock);
VirtIOGPURect rect = {
.x = 0,
.y = 0,
.width = (u32)width,
.height = (u32)height,
};
auto old_framebuffer_id = m_framebuffer_id;
auto new_framebuffer_id = create_2d_resource(rect);
ensure_backing_storage(*m_framebuffer, calculate_framebuffer_size(width, height), new_framebuffer_id);
set_scanout_resource(m_chosen_scanout.value(), new_framebuffer_id, rect);
detach_backing_storage(old_framebuffer_id);
delete_resource(old_framebuffer_id);
m_framebuffer_id = new_framebuffer_id;
m_display_info.rect = rect;
return true;
transfer_framebuffer_data_to_host(scanout, dirty_rect, resource_id);
flush_displayed_image(dirty_rect, resource_id);
}
VirtIOGPUResourceID VirtIOGPU::allocate_resource_id()
@ -361,22 +284,4 @@ void VirtIOGPU::delete_resource(VirtIOGPUResourceID resource_id)
VERIFY(response.type == static_cast<u32>(VirtIOGPUCtrlType::VIRTIO_GPU_RESP_OK_NODATA));
}
size_t VirtIOGPU::framebuffer_size_in_bytes() const
{
return m_display_info.rect.width * m_display_info.rect.height * sizeof(u32);
}
void VirtIOGPU::clear_to_black()
{
size_t width = m_display_info.rect.width;
size_t height = m_display_info.rect.height;
u8* data = m_framebuffer->vaddr().as_ptr();
for (size_t i = 0; i < width * height; ++i) {
data[4 * i + 0] = 0x00;
data[4 * i + 1] = 0x00;
data[4 * i + 2] = 0x00;
data[4 * i + 3] = 0xff;
}
}
}