mirror of
https://github.com/RGBCube/serenity
synced 2025-07-28 01:27:44 +00:00
Kernel/Graphics: Bring back the mmap interface for DisplayConnectors
The mmap interface was removed when we introduced the DisplayConnector class, as it was quite unsafe to use and didn't handle switching between graphical and text modes safely. By using the SharedFramebufferVMObject, we are able to elegantly coordinate the switch by remapping the attached mmap'ed-Memory::Region(s) with different mappings, therefore, keeping WindowServer to think that the mappings it has are still valid, while they are going to a different physical range until we are back to the graphical mode (after a switch from text mode). Most drivers take advantage of the fact that we know where is the actual framebuffer in physical memory space, the SharedFramebufferVMObject is created with that information. However, the VirtIO driver is different in that aspect, because it relies on DMA transactions to show graphics on the framebuffer, so the SharedFramebufferVMObject is created with that mindset to support the arbitrary framebuffer location in physical memory space.
This commit is contained in:
Liav A
Linus Groh
parent
3d22917548
commit
e2ed6ef741
19 changed files with 309 additions and 341 deletions
|
|
@ -24,8 +24,10 @@ NonnullRefPtr<VirtIODisplayConnector> VirtIODisplayConnector::must_create(VirtIO
|
|||
return connector;
|
||||
}
|
||||
|
||||
static_assert((MAX_VIRTIOGPU_RESOLUTION_WIDTH * MAX_VIRTIOGPU_RESOLUTION_HEIGHT * sizeof(u32) * 2) % PAGE_SIZE == 0);
|
||||
|
||||
VirtIODisplayConnector::VirtIODisplayConnector(VirtIOGraphicsAdapter& graphics_adapter, Graphics::VirtIOGPU::ScanoutID scanout_id)
|
||||
: DisplayConnector()
|
||||
: DisplayConnector((MAX_VIRTIOGPU_RESOLUTION_WIDTH * MAX_VIRTIOGPU_RESOLUTION_HEIGHT * sizeof(u32) * 2), false)
|
||||
, m_graphics_adapter(graphics_adapter)
|
||||
, m_scanout_id(scanout_id)
|
||||
{
|
||||
|
|
@ -48,14 +50,14 @@ ErrorOr<void> VirtIODisplayConnector::set_mode_setting(ModeSetting const& mode_s
|
|||
return Error::from_errno(ENOTSUP);
|
||||
|
||||
auto& info = m_display_info;
|
||||
|
||||
info.rect = {
|
||||
.x = 0,
|
||||
.y = 0,
|
||||
.width = (u32)mode_setting.horizontal_active,
|
||||
.height = (u32)mode_setting.vertical_active,
|
||||
};
|
||||
TRY(create_framebuffer());
|
||||
|
||||
TRY(m_graphics_adapter->mode_set_resolution({}, *this, mode_setting.horizontal_active, mode_setting.vertical_active));
|
||||
DisplayConnector::ModeSetting mode_set {
|
||||
.horizontal_stride = info.rect.width * sizeof(u32),
|
||||
.pixel_clock_in_khz = 0, // Note: There's no pixel clock in paravirtualized hardware
|
||||
|
|
@ -71,6 +73,8 @@ ErrorOr<void> VirtIODisplayConnector::set_mode_setting(ModeSetting const& mode_s
|
|||
.vertical_offset = 0,
|
||||
};
|
||||
m_current_mode_setting = mode_set;
|
||||
|
||||
m_display_info.enabled = 1;
|
||||
return {};
|
||||
}
|
||||
ErrorOr<void> VirtIODisplayConnector::set_safe_mode_setting()
|
||||
|
|
@ -96,9 +100,9 @@ ErrorOr<void> VirtIODisplayConnector::set_y_offset(size_t y)
|
|||
{
|
||||
VERIFY(m_control_lock.is_locked());
|
||||
if (y == 0)
|
||||
m_current_buffer = &m_main_buffer;
|
||||
m_last_set_buffer_index.store(0);
|
||||
else if (y == m_display_info.rect.height)
|
||||
m_current_buffer = &m_back_buffer;
|
||||
m_last_set_buffer_index.store(1);
|
||||
else
|
||||
return Error::from_errno(EINVAL);
|
||||
return {};
|
||||
|
|
@ -108,25 +112,11 @@ ErrorOr<void> VirtIODisplayConnector::unblank()
|
|||
return Error::from_errno(ENOTIMPL);
|
||||
}
|
||||
|
||||
ErrorOr<size_t> VirtIODisplayConnector::write_to_first_surface(u64 offset, UserOrKernelBuffer const& buffer, size_t length)
|
||||
{
|
||||
VERIFY(m_control_lock.is_locked());
|
||||
if (offset + length > (m_buffer_size * 2))
|
||||
return Error::from_errno(EOVERFLOW);
|
||||
if (offset < m_buffer_size && (offset + length) > (m_buffer_size))
|
||||
return Error::from_errno(EOVERFLOW);
|
||||
if (offset < m_buffer_size) {
|
||||
TRY(buffer.read(m_main_buffer.framebuffer_data + offset, 0, length));
|
||||
} else {
|
||||
TRY(buffer.read(m_back_buffer.framebuffer_data + offset - m_buffer_size, 0, length));
|
||||
}
|
||||
|
||||
return length;
|
||||
}
|
||||
|
||||
ErrorOr<void> VirtIODisplayConnector::flush_rectangle(size_t buffer_index, FBRect const& rect)
|
||||
{
|
||||
VERIFY(m_flushing_lock.is_locked());
|
||||
if (!is_valid_buffer_index(buffer_index))
|
||||
return Error::from_errno(EINVAL);
|
||||
SpinlockLocker locker(m_graphics_adapter->operation_lock());
|
||||
Graphics::VirtIOGPU::Protocol::Rect dirty_rect {
|
||||
.x = rect.x,
|
||||
|
|
@ -135,23 +125,13 @@ ErrorOr<void> VirtIODisplayConnector::flush_rectangle(size_t buffer_index, FBRec
|
|||
.height = rect.height
|
||||
};
|
||||
|
||||
auto& buffer = buffer_from_index(buffer_index);
|
||||
transfer_framebuffer_data_to_host(dirty_rect, buffer);
|
||||
if (&buffer == m_current_buffer) {
|
||||
bool main_buffer = (buffer_index == 0);
|
||||
m_graphics_adapter->transfer_framebuffer_data_to_host({}, *this, dirty_rect, main_buffer);
|
||||
if (m_last_set_buffer_index.load() == buffer_index) {
|
||||
// Flushing directly to screen
|
||||
flush_displayed_image(dirty_rect, buffer);
|
||||
buffer.dirty_rect = {};
|
||||
flush_displayed_image(dirty_rect, main_buffer);
|
||||
} else {
|
||||
if (buffer.dirty_rect.width == 0 || buffer.dirty_rect.height == 0) {
|
||||
buffer.dirty_rect = dirty_rect;
|
||||
} else {
|
||||
auto current_dirty_right = buffer.dirty_rect.x + buffer.dirty_rect.width;
|
||||
auto current_dirty_bottom = buffer.dirty_rect.y + buffer.dirty_rect.height;
|
||||
buffer.dirty_rect.x = min(buffer.dirty_rect.x, dirty_rect.x);
|
||||
buffer.dirty_rect.y = min(buffer.dirty_rect.y, dirty_rect.y);
|
||||
buffer.dirty_rect.width = max(current_dirty_right, dirty_rect.x + dirty_rect.width) - buffer.dirty_rect.x;
|
||||
buffer.dirty_rect.height = max(current_dirty_bottom, dirty_rect.y + dirty_rect.height) - buffer.dirty_rect.y;
|
||||
}
|
||||
set_dirty_displayed_rect(dirty_rect, main_buffer);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
|
@ -166,24 +146,14 @@ ErrorOr<void> VirtIODisplayConnector::flush_first_surface()
|
|||
.width = m_display_info.rect.width,
|
||||
.height = m_display_info.rect.height
|
||||
};
|
||||
auto& buffer = buffer_from_index(0);
|
||||
transfer_framebuffer_data_to_host(dirty_rect, buffer);
|
||||
if (&buffer == m_current_buffer) {
|
||||
// Flushing directly to screen
|
||||
flush_displayed_image(dirty_rect, buffer);
|
||||
buffer.dirty_rect = {};
|
||||
} else {
|
||||
if (buffer.dirty_rect.width == 0 || buffer.dirty_rect.height == 0) {
|
||||
buffer.dirty_rect = dirty_rect;
|
||||
} else {
|
||||
auto current_dirty_right = buffer.dirty_rect.x + buffer.dirty_rect.width;
|
||||
auto current_dirty_bottom = buffer.dirty_rect.y + buffer.dirty_rect.height;
|
||||
buffer.dirty_rect.x = min(buffer.dirty_rect.x, dirty_rect.x);
|
||||
buffer.dirty_rect.y = min(buffer.dirty_rect.y, dirty_rect.y);
|
||||
buffer.dirty_rect.width = max(current_dirty_right, dirty_rect.x + dirty_rect.width) - buffer.dirty_rect.x;
|
||||
buffer.dirty_rect.height = max(current_dirty_bottom, dirty_rect.y + dirty_rect.height) - buffer.dirty_rect.y;
|
||||
}
|
||||
}
|
||||
|
||||
auto current_buffer_index = m_last_set_buffer_index.load();
|
||||
VERIFY(is_valid_buffer_index(current_buffer_index));
|
||||
|
||||
bool main_buffer = (current_buffer_index == 0);
|
||||
m_graphics_adapter->transfer_framebuffer_data_to_host({}, *this, dirty_rect, main_buffer);
|
||||
// Flushing directly to screen
|
||||
flush_displayed_image(dirty_rect, main_buffer);
|
||||
return {};
|
||||
}
|
||||
|
||||
|
|
@ -201,11 +171,21 @@ void VirtIODisplayConnector::disable_console()
|
|||
m_console->disable();
|
||||
}
|
||||
|
||||
void VirtIODisplayConnector::clear_to_black(Buffer& buffer)
|
||||
void VirtIODisplayConnector::set_edid_bytes(Badge<VirtIOGraphicsAdapter>, Array<u8, 128> const& edid_bytes)
|
||||
{
|
||||
DisplayConnector::set_edid_bytes(edid_bytes);
|
||||
}
|
||||
|
||||
Graphics::VirtIOGPU::Protocol::DisplayInfoResponse::Display VirtIODisplayConnector::display_information(Badge<VirtIOGraphicsAdapter>) const
|
||||
{
|
||||
return m_display_info;
|
||||
}
|
||||
|
||||
void VirtIODisplayConnector::clear_to_black()
|
||||
{
|
||||
size_t width = m_display_info.rect.width;
|
||||
size_t height = m_display_info.rect.height;
|
||||
u8* data = buffer.framebuffer_data;
|
||||
u8* data = framebuffer_data();
|
||||
for (size_t i = 0; i < width * height; ++i) {
|
||||
data[4 * i + 0] = 0x00;
|
||||
data[4 * i + 1] = 0x00;
|
||||
|
|
@ -214,7 +194,7 @@ void VirtIODisplayConnector::clear_to_black(Buffer& buffer)
|
|||
}
|
||||
}
|
||||
|
||||
void VirtIODisplayConnector::draw_ntsc_test_pattern(Buffer& buffer)
|
||||
void VirtIODisplayConnector::draw_ntsc_test_pattern(Badge<VirtIOGraphicsAdapter>)
|
||||
{
|
||||
constexpr u8 colors[12][4] = {
|
||||
{ 0xff, 0xff, 0xff, 0xff }, // White
|
||||
|
|
@ -232,134 +212,57 @@ void VirtIODisplayConnector::draw_ntsc_test_pattern(Buffer& buffer)
|
|||
};
|
||||
size_t width = m_display_info.rect.width;
|
||||
size_t height = m_display_info.rect.height;
|
||||
u8* data = buffer.framebuffer_data;
|
||||
u8* data = framebuffer_data();
|
||||
// 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);
|
||||
for (size_t i = 0; i < 2; ++i) {
|
||||
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 {
|
||||
// Solid black
|
||||
color = 10;
|
||||
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];
|
||||
}
|
||||
}
|
||||
u8* pixel = &data[4 * (y * width + x)];
|
||||
for (int i = 0; i < 4; ++i) {
|
||||
pixel[i] = colors[color][i];
|
||||
}
|
||||
}
|
||||
data = data + (width * height * sizeof(u32));
|
||||
}
|
||||
dbgln_if(VIRTIO_DEBUG, "Finish drawing the pattern");
|
||||
}
|
||||
|
||||
u8* VirtIODisplayConnector::framebuffer_data()
|
||||
{
|
||||
return m_current_buffer->framebuffer_data;
|
||||
}
|
||||
|
||||
ErrorOr<void> VirtIODisplayConnector::create_framebuffer()
|
||||
{
|
||||
SpinlockLocker locker(m_graphics_adapter->operation_lock());
|
||||
// First delete any existing framebuffers to free the memory first
|
||||
m_framebuffer = nullptr;
|
||||
m_framebuffer_sink_vmobject = nullptr;
|
||||
|
||||
// Allocate frame buffer for both front and back
|
||||
m_buffer_size = calculate_framebuffer_size(m_display_info.rect.width, m_display_info.rect.height);
|
||||
auto region_name = TRY(KString::formatted("VirtGPU FrameBuffer #{}", m_scanout_id.value()));
|
||||
m_framebuffer = TRY(MM.allocate_kernel_region(m_buffer_size * 2, region_name->view(), Memory::Region::Access::ReadWrite, AllocationStrategy::AllocateNow));
|
||||
auto write_sink_page = TRY(MM.allocate_user_physical_page(Memory::MemoryManager::ShouldZeroFill::No));
|
||||
auto num_needed_pages = m_framebuffer->vmobject().page_count();
|
||||
|
||||
NonnullRefPtrVector<Memory::PhysicalPage> pages;
|
||||
for (auto i = 0u; i < num_needed_pages; ++i) {
|
||||
TRY(pages.try_append(write_sink_page));
|
||||
}
|
||||
m_framebuffer_sink_vmobject = TRY(Memory::AnonymousVMObject::try_create_with_physical_pages(pages.span()));
|
||||
|
||||
m_current_buffer = &buffer_from_index(m_last_set_buffer_index.load());
|
||||
create_buffer(m_main_buffer, 0, m_buffer_size);
|
||||
create_buffer(m_back_buffer, m_buffer_size, m_buffer_size);
|
||||
|
||||
return {};
|
||||
}
|
||||
|
||||
void VirtIODisplayConnector::set_edid_bytes(Badge<VirtIOGraphicsAdapter>, Array<u8, 128> const& edid_bytes)
|
||||
{
|
||||
DisplayConnector::set_edid_bytes(edid_bytes);
|
||||
}
|
||||
|
||||
Graphics::VirtIOGPU::Protocol::DisplayInfoResponse::Display VirtIODisplayConnector::display_information(Badge<VirtIOGraphicsAdapter>)
|
||||
{
|
||||
return m_display_info;
|
||||
}
|
||||
|
||||
void VirtIODisplayConnector::create_buffer(Buffer& buffer, size_t framebuffer_offset, size_t framebuffer_size)
|
||||
void VirtIODisplayConnector::flush_displayed_image(Graphics::VirtIOGPU::Protocol::Rect const& dirty_rect, bool main_buffer)
|
||||
{
|
||||
VERIFY(m_graphics_adapter->operation_lock().is_locked());
|
||||
buffer.framebuffer_offset = framebuffer_offset;
|
||||
buffer.framebuffer_data = m_framebuffer->vaddr().as_ptr() + framebuffer_offset;
|
||||
|
||||
// 1. Create BUFFER using VIRTIO_GPU_CMD_RESOURCE_CREATE_2D
|
||||
if (buffer.resource_id.value() != 0)
|
||||
m_graphics_adapter->delete_resource(buffer.resource_id);
|
||||
buffer.resource_id = m_graphics_adapter->create_2d_resource(m_display_info.rect);
|
||||
|
||||
// 2. Attach backing storage using VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING
|
||||
m_graphics_adapter->ensure_backing_storage(buffer.resource_id, *m_framebuffer, buffer.framebuffer_offset, framebuffer_size);
|
||||
// 3. Use VIRTIO_GPU_CMD_SET_SCANOUT to link the framebuffer to a display scanout.
|
||||
if (&buffer == m_current_buffer)
|
||||
m_graphics_adapter->set_scanout_resource(m_scanout_id, buffer.resource_id, m_display_info.rect);
|
||||
// 4. Render our test pattern
|
||||
draw_ntsc_test_pattern(buffer);
|
||||
// 5. 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, buffer);
|
||||
// 6. Use VIRTIO_GPU_CMD_RESOURCE_FLUSH to flush the updated resource to the display.
|
||||
if (&buffer == m_current_buffer)
|
||||
flush_displayed_image(m_display_info.rect, buffer);
|
||||
|
||||
// Make sure we constrain the existing dirty rect (if any)
|
||||
if (buffer.dirty_rect.width != 0 || buffer.dirty_rect.height != 0) {
|
||||
auto dirty_right = buffer.dirty_rect.x + buffer.dirty_rect.width;
|
||||
auto dirty_bottom = buffer.dirty_rect.y + buffer.dirty_rect.height;
|
||||
buffer.dirty_rect.width = min(dirty_right, m_display_info.rect.x + m_display_info.rect.width) - buffer.dirty_rect.x;
|
||||
buffer.dirty_rect.height = min(dirty_bottom, m_display_info.rect.y + m_display_info.rect.height) - buffer.dirty_rect.y;
|
||||
}
|
||||
|
||||
m_display_info.enabled = 1;
|
||||
m_graphics_adapter->flush_displayed_image({}, *this, dirty_rect, main_buffer);
|
||||
}
|
||||
|
||||
void VirtIODisplayConnector::transfer_framebuffer_data_to_host(Graphics::VirtIOGPU::Protocol::Rect const& rect, Buffer& buffer)
|
||||
void VirtIODisplayConnector::set_dirty_displayed_rect(Graphics::VirtIOGPU::Protocol::Rect const& dirty_rect, bool main_buffer)
|
||||
{
|
||||
m_graphics_adapter->transfer_framebuffer_data_to_host(m_scanout_id, buffer.resource_id, rect);
|
||||
}
|
||||
|
||||
void VirtIODisplayConnector::flush_dirty_window(Graphics::VirtIOGPU::Protocol::Rect const& dirty_rect, Buffer& buffer)
|
||||
{
|
||||
m_graphics_adapter->flush_dirty_rectangle(m_scanout_id, buffer.resource_id, dirty_rect);
|
||||
}
|
||||
|
||||
void VirtIODisplayConnector::flush_displayed_image(Graphics::VirtIOGPU::Protocol::Rect const& dirty_rect, Buffer& buffer)
|
||||
{
|
||||
m_graphics_adapter->flush_displayed_image(buffer.resource_id, dirty_rect);
|
||||
VERIFY(m_graphics_adapter->operation_lock().is_locked());
|
||||
m_graphics_adapter->set_dirty_displayed_rect({}, *this, dirty_rect, main_buffer);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,20 +29,15 @@ class VirtIODisplayConnector final : public DisplayConnector {
|
|||
friend class Graphics::VirtIOGPU::Console;
|
||||
friend class DeviceManagement;
|
||||
|
||||
private:
|
||||
struct Buffer {
|
||||
size_t framebuffer_offset { 0 };
|
||||
u8* framebuffer_data { nullptr };
|
||||
Graphics::VirtIOGPU::Protocol::Rect dirty_rect {};
|
||||
Graphics::VirtIOGPU::ResourceID resource_id { 0 };
|
||||
};
|
||||
|
||||
public:
|
||||
static NonnullRefPtr<VirtIODisplayConnector> must_create(VirtIOGraphicsAdapter& graphics_adapter, Graphics::VirtIOGPU::ScanoutID scanout_id);
|
||||
|
||||
void set_edid_bytes(Badge<VirtIOGraphicsAdapter>, Array<u8, 128> const& edid_bytes);
|
||||
void set_safe_mode_setting_after_initialization(Badge<VirtIOGraphicsAdapter>);
|
||||
Graphics::VirtIOGPU::Protocol::DisplayInfoResponse::Display display_information(Badge<VirtIOGraphicsAdapter>);
|
||||
Graphics::VirtIOGPU::ScanoutID scanout_id() const { return m_scanout_id; }
|
||||
Graphics::VirtIOGPU::Protocol::DisplayInfoResponse::Display display_information(Badge<VirtIOGraphicsAdapter>) const;
|
||||
|
||||
void draw_ntsc_test_pattern(Badge<VirtIOGraphicsAdapter>);
|
||||
|
||||
private:
|
||||
void initialize_console();
|
||||
|
|
@ -59,45 +54,28 @@ private:
|
|||
// Note: Paravirtualized hardware doesn't require a defined refresh rate for modesetting.
|
||||
virtual bool refresh_rate_support() const override { return false; }
|
||||
|
||||
virtual ErrorOr<size_t> write_to_first_surface(u64 offset, UserOrKernelBuffer const&, size_t length) override;
|
||||
virtual ErrorOr<void> flush_first_surface() override;
|
||||
virtual ErrorOr<void> flush_rectangle(size_t buffer_index, FBRect const& rect) override;
|
||||
|
||||
virtual void enable_console() override;
|
||||
virtual void disable_console() override;
|
||||
|
||||
static bool is_valid_buffer_index(size_t buffer_index)
|
||||
{
|
||||
return buffer_index == 0 || buffer_index == 1;
|
||||
}
|
||||
|
||||
private:
|
||||
VirtIODisplayConnector(VirtIOGraphicsAdapter& graphics_adapter, Graphics::VirtIOGPU::ScanoutID scanout_id);
|
||||
|
||||
void flush_displayed_image(Graphics::VirtIOGPU::Protocol::Rect const& dirty_rect, bool main_buffer);
|
||||
void set_dirty_displayed_rect(Graphics::VirtIOGPU::Protocol::Rect const& dirty_rect, bool main_buffer);
|
||||
|
||||
void query_display_information();
|
||||
ErrorOr<void> query_edid_from_virtio_adapter();
|
||||
void query_display_edid();
|
||||
|
||||
void flush_dirty_window(Graphics::VirtIOGPU::Protocol::Rect const&, Buffer&);
|
||||
void transfer_framebuffer_data_to_host(Graphics::VirtIOGPU::Protocol::Rect const&, Buffer&);
|
||||
void flush_displayed_image(Graphics::VirtIOGPU::Protocol::Rect const&, Buffer&);
|
||||
|
||||
// Basic 2D framebuffer methods
|
||||
static size_t calculate_framebuffer_size(size_t width, size_t height)
|
||||
{
|
||||
// VirtIO resources can only map on page boundaries!
|
||||
return Memory::page_round_up(sizeof(u32) * width * height).value();
|
||||
}
|
||||
u8* framebuffer_data();
|
||||
void draw_ntsc_test_pattern(Buffer&);
|
||||
void clear_to_black(Buffer&);
|
||||
ErrorOr<void> create_framebuffer();
|
||||
void create_buffer(Buffer&, size_t, size_t);
|
||||
void set_buffer(int);
|
||||
static bool is_valid_buffer_index(int buffer_index)
|
||||
{
|
||||
return buffer_index == 0 || buffer_index == 1;
|
||||
}
|
||||
Buffer& buffer_from_index(int buffer_index)
|
||||
{
|
||||
return buffer_index == 0 ? m_main_buffer : m_back_buffer;
|
||||
}
|
||||
Buffer& current_buffer() const { return *m_current_buffer; }
|
||||
void clear_to_black();
|
||||
|
||||
// Member data
|
||||
// Context used for kernel operations (e.g. flushing resources to scanout)
|
||||
|
|
@ -109,13 +87,7 @@ private:
|
|||
Graphics::VirtIOGPU::ScanoutID m_scanout_id;
|
||||
|
||||
// 2D framebuffer Member data
|
||||
size_t m_buffer_size { 0 };
|
||||
Buffer* m_current_buffer { nullptr };
|
||||
Atomic<int, AK::memory_order_relaxed> m_last_set_buffer_index { 0 };
|
||||
Buffer m_main_buffer;
|
||||
Buffer m_back_buffer;
|
||||
OwnPtr<Memory::Region> m_framebuffer;
|
||||
RefPtr<Memory::VMObject> m_framebuffer_sink_vmobject;
|
||||
Atomic<size_t, AK::memory_order_relaxed> m_last_set_buffer_index { 0 };
|
||||
|
||||
constexpr static size_t NUM_TRANSFER_REGION_PAGES = 256;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -48,6 +48,83 @@ ErrorOr<void> VirtIOGraphicsAdapter::initialize_adapter()
|
|||
return {};
|
||||
}
|
||||
|
||||
ErrorOr<void> VirtIOGraphicsAdapter::mode_set_resolution(Badge<VirtIODisplayConnector>, VirtIODisplayConnector& connector, size_t width, size_t height)
|
||||
{
|
||||
SpinlockLocker locker(m_operation_lock);
|
||||
VERIFY(connector.scanout_id() < VIRTIO_GPU_MAX_SCANOUTS);
|
||||
auto rounded_buffer_size = TRY(calculate_framebuffer_size(width, height));
|
||||
TRY(attach_physical_range_to_framebuffer(connector, true, 0, rounded_buffer_size));
|
||||
TRY(attach_physical_range_to_framebuffer(connector, false, rounded_buffer_size, rounded_buffer_size));
|
||||
return {};
|
||||
}
|
||||
|
||||
void VirtIOGraphicsAdapter::set_dirty_displayed_rect(Badge<VirtIODisplayConnector>, VirtIODisplayConnector& connector, Graphics::VirtIOGPU::Protocol::Rect const& dirty_rect, bool main_buffer)
|
||||
{
|
||||
VERIFY(m_operation_lock.is_locked());
|
||||
VERIFY(connector.scanout_id() < VIRTIO_GPU_MAX_SCANOUTS);
|
||||
Scanout::PhysicalBuffer& buffer = main_buffer ? m_scanouts[connector.scanout_id().value()].main_buffer : m_scanouts[connector.scanout_id().value()].back_buffer;
|
||||
if (buffer.dirty_rect.width == 0 || buffer.dirty_rect.height == 0) {
|
||||
buffer.dirty_rect = dirty_rect;
|
||||
} else {
|
||||
auto current_dirty_right = buffer.dirty_rect.x + buffer.dirty_rect.width;
|
||||
auto current_dirty_bottom = buffer.dirty_rect.y + buffer.dirty_rect.height;
|
||||
buffer.dirty_rect.x = min(buffer.dirty_rect.x, dirty_rect.x);
|
||||
buffer.dirty_rect.y = min(buffer.dirty_rect.y, dirty_rect.y);
|
||||
buffer.dirty_rect.width = max(current_dirty_right, dirty_rect.x + dirty_rect.width) - buffer.dirty_rect.x;
|
||||
buffer.dirty_rect.height = max(current_dirty_bottom, dirty_rect.y + dirty_rect.height) - buffer.dirty_rect.y;
|
||||
}
|
||||
}
|
||||
|
||||
void VirtIOGraphicsAdapter::flush_displayed_image(Badge<VirtIODisplayConnector>, VirtIODisplayConnector& connector, Graphics::VirtIOGPU::Protocol::Rect const& dirty_rect, bool main_buffer)
|
||||
{
|
||||
VERIFY(m_operation_lock.is_locked());
|
||||
VERIFY(connector.scanout_id() < VIRTIO_GPU_MAX_SCANOUTS);
|
||||
Scanout::PhysicalBuffer& buffer = main_buffer ? m_scanouts[connector.scanout_id().value()].main_buffer : m_scanouts[connector.scanout_id().value()].back_buffer;
|
||||
flush_displayed_image(buffer.resource_id, dirty_rect);
|
||||
buffer.dirty_rect = {};
|
||||
}
|
||||
|
||||
void VirtIOGraphicsAdapter::transfer_framebuffer_data_to_host(Badge<VirtIODisplayConnector>, VirtIODisplayConnector& connector, Graphics::VirtIOGPU::Protocol::Rect const& rect, bool main_buffer)
|
||||
{
|
||||
VERIFY(m_operation_lock.is_locked());
|
||||
VERIFY(connector.scanout_id() < VIRTIO_GPU_MAX_SCANOUTS);
|
||||
Scanout::PhysicalBuffer& buffer = main_buffer ? m_scanouts[connector.scanout_id().value()].main_buffer : m_scanouts[connector.scanout_id().value()].back_buffer;
|
||||
transfer_framebuffer_data_to_host(connector.scanout_id(), buffer.resource_id, rect);
|
||||
}
|
||||
|
||||
ErrorOr<void> VirtIOGraphicsAdapter::attach_physical_range_to_framebuffer(VirtIODisplayConnector& connector, bool main_buffer, size_t framebuffer_offset, size_t framebuffer_size)
|
||||
{
|
||||
VERIFY(m_operation_lock.is_locked());
|
||||
Scanout::PhysicalBuffer& buffer = main_buffer ? m_scanouts[connector.scanout_id().value()].main_buffer : m_scanouts[connector.scanout_id().value()].back_buffer;
|
||||
buffer.framebuffer_offset = framebuffer_offset;
|
||||
|
||||
// 1. Create BUFFER using VIRTIO_GPU_CMD_RESOURCE_CREATE_2D
|
||||
if (buffer.resource_id.value() != 0)
|
||||
delete_resource(buffer.resource_id);
|
||||
auto display_info = connector.display_information({});
|
||||
buffer.resource_id = create_2d_resource(display_info.rect);
|
||||
|
||||
// 2. Attach backing storage using VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING
|
||||
ensure_backing_storage(buffer.resource_id, connector.framebuffer_region(), buffer.framebuffer_offset, framebuffer_size);
|
||||
// 3. Use VIRTIO_GPU_CMD_SET_SCANOUT to link the framebuffer to a display scanout.
|
||||
set_scanout_resource(connector.scanout_id(), buffer.resource_id, display_info.rect);
|
||||
// 4. Render our test pattern
|
||||
connector.draw_ntsc_test_pattern({});
|
||||
// 5. Use VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D to update the host resource from guest memory.
|
||||
transfer_framebuffer_data_to_host(connector.scanout_id(), buffer.resource_id, display_info.rect);
|
||||
// 6. Use VIRTIO_GPU_CMD_RESOURCE_FLUSH to flush the updated resource to the display.
|
||||
flush_displayed_image(buffer.resource_id, display_info.rect);
|
||||
|
||||
// Make sure we constrain the existing dirty rect (if any)
|
||||
if (buffer.dirty_rect.width != 0 || buffer.dirty_rect.height != 0) {
|
||||
auto dirty_right = buffer.dirty_rect.x + buffer.dirty_rect.width;
|
||||
auto dirty_bottom = buffer.dirty_rect.y + buffer.dirty_rect.height;
|
||||
buffer.dirty_rect.width = min(dirty_right, display_info.rect.x + display_info.rect.width) - buffer.dirty_rect.x;
|
||||
buffer.dirty_rect.height = min(dirty_bottom, display_info.rect.y + display_info.rect.height) - buffer.dirty_rect.y;
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
VirtIOGraphicsAdapter::VirtIOGraphicsAdapter(PCI::DeviceIdentifier const& device_identifier, NonnullOwnPtr<Memory::Region> scratch_space_region)
|
||||
: VirtIO::Device(device_identifier)
|
||||
, m_scratch_space(move(scratch_space_region))
|
||||
|
|
|
|||
|
|
@ -50,10 +50,25 @@ public:
|
|||
Graphics::VirtIOGPU::ResourceID allocate_resource_id(Badge<VirtIODisplayConnector>);
|
||||
Graphics::VirtIOGPU::ContextID allocate_context_id(Badge<VirtIODisplayConnector>);
|
||||
|
||||
ErrorOr<void> mode_set_resolution(Badge<VirtIODisplayConnector>, VirtIODisplayConnector&, size_t width, size_t height);
|
||||
void set_dirty_displayed_rect(Badge<VirtIODisplayConnector>, VirtIODisplayConnector&, Graphics::VirtIOGPU::Protocol::Rect const& dirty_rect, bool main_buffer);
|
||||
void flush_displayed_image(Badge<VirtIODisplayConnector>, VirtIODisplayConnector&, Graphics::VirtIOGPU::Protocol::Rect const& dirty_rect, bool main_buffer);
|
||||
void transfer_framebuffer_data_to_host(Badge<VirtIODisplayConnector>, VirtIODisplayConnector&, Graphics::VirtIOGPU::Protocol::Rect const& rect, bool main_buffer);
|
||||
|
||||
private:
|
||||
ErrorOr<void> attach_physical_range_to_framebuffer(VirtIODisplayConnector& connector, bool main_buffer, size_t framebuffer_offset, size_t framebuffer_size);
|
||||
|
||||
void flush_dirty_rectangle(Graphics::VirtIOGPU::ScanoutID, Graphics::VirtIOGPU::ResourceID, Graphics::VirtIOGPU::Protocol::Rect const& dirty_rect);
|
||||
struct Scanout {
|
||||
struct PhysicalBuffer {
|
||||
size_t framebuffer_offset { 0 };
|
||||
Graphics::VirtIOGPU::Protocol::Rect dirty_rect {};
|
||||
Graphics::VirtIOGPU::ResourceID resource_id { 0 };
|
||||
};
|
||||
|
||||
RefPtr<VirtIODisplayConnector> display_connector;
|
||||
PhysicalBuffer main_buffer;
|
||||
PhysicalBuffer back_buffer;
|
||||
};
|
||||
|
||||
VirtIOGraphicsAdapter(PCI::DeviceIdentifier const&, NonnullOwnPtr<Memory::Region> scratch_space_region);
|
||||
|
|
@ -65,6 +80,13 @@ private:
|
|||
u32 get_pending_events();
|
||||
void clear_pending_events(u32 event_bitmask);
|
||||
|
||||
// 2D framebuffer stuff
|
||||
static ErrorOr<FlatPtr> calculate_framebuffer_size(size_t width, size_t height)
|
||||
{
|
||||
// VirtIO resources can only map on page boundaries!
|
||||
return Memory::page_round_up(sizeof(u32) * width * height);
|
||||
}
|
||||
|
||||
// 3D Command stuff
|
||||
Graphics::VirtIOGPU::ContextID create_context();
|
||||
void attach_resource_to_context(Graphics::VirtIOGPU::ResourceID resource_id, Graphics::VirtIOGPU::ContextID context_id);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue