* Copyright 2023, Jérôme Duval, jerome.duval@gmail.com.
* Distributed under the terms of the MIT License.
*/
#include <new>
#include <graphic_driver.h>
#include <lock.h>
#include <virtio.h>
#include <virtio_info.h>
#include <util/AutoLock.h>
#include "viogpu.h"
#define VIRTIO_GPU_DRIVER_MODULE_NAME "drivers/graphics/virtio_gpu/driver_v1"
#define VIRTIO_GPU_DEVICE_MODULE_NAME "drivers/graphics/virtio_gpu/device_v1"
#define VIRTIO_GPU_DEVICE_ID_GENERATOR "virtio_gpu/device_id"
typedef struct {
device_node* node;
::virtio_device virtio_device;
virtio_device_interface* virtio;
uint64 features;
::virtio_queue controlQueue;
mutex commandLock;
area_id commandArea;
addr_t commandBuffer;
phys_addr_t commandPhysAddr;
sem_id commandDone;
uint64 fenceId;
::virtio_queue cursorQueue;
int displayResourceId;
uint32 framebufferWidth;
uint32 framebufferHeight;
area_id framebufferArea;
addr_t framebuffer;
size_t framebufferSize;
uint32 displayWidth;
uint32 displayHeight;
thread_id updateThread;
bool updateThreadRunning;
area_id sharedArea;
virtio_gpu_shared_info* sharedInfo;
} virtio_gpu_driver_info;
typedef struct {
virtio_gpu_driver_info* info;
} virtio_gpu_handle;
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <fs/devfs.h>
#define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))
#define DEVICE_NAME "virtio_gpu"
#define ACCELERANT_NAME "virtio_gpu.accelerant"
#ifdef TRACE_VIRTIO_GPU
# define TRACE(x...) dprintf(DEVICE_NAME ": " x)
#else
# define TRACE(x...) ;
#endif
#define ERROR(x...) dprintf("\33[33m" DEVICE_NAME ":\33[0m " x)
#define CALLED() TRACE("CALLED %s\n", __PRETTY_FUNCTION__)
static device_manager_info* sDeviceManager;
static void virtio_gpu_vqwait(void* driverCookie, void* cookie);
const char*
get_feature_name(uint64 feature)
{
switch (feature) {
case VIRTIO_GPU_F_VIRGL:
return "virgl";
case VIRTIO_GPU_F_EDID:
return "edid";
case VIRTIO_GPU_F_RESOURCE_UUID:
return "res_uuid";
case VIRTIO_GPU_F_RESOURCE_BLOB:
return "res_blob";
}
return NULL;
}
static status_t
virtio_gpu_drain_queues(virtio_gpu_driver_info* info)
{
while (info->virtio->queue_dequeue(info->controlQueue, NULL, NULL))
;
while (info->virtio->queue_dequeue(info->cursorQueue, NULL, NULL))
;
return B_OK;
}
status_t
virtio_gpu_send_cmd(virtio_gpu_driver_info* info, void *cmd, size_t cmdSize, void *response,
size_t responseSize)
{
struct virtio_gpu_ctrl_hdr *hdr = (struct virtio_gpu_ctrl_hdr *)info->commandBuffer;
struct virtio_gpu_ctrl_hdr *responseHdr = (struct virtio_gpu_ctrl_hdr *)response;
memcpy((void*)info->commandBuffer, cmd, cmdSize);
memset((void*)(info->commandBuffer + cmdSize), 0, responseSize);
hdr->flags |= VIRTIO_GPU_FLAG_FENCE;
hdr->fence_id = ++info->fenceId;
physical_entry entries[] {
{ info->commandPhysAddr, cmdSize },
{ info->commandPhysAddr + cmdSize, responseSize },
};
if (!info->virtio->queue_is_empty(info->controlQueue))
return B_ERROR;
status_t status = info->virtio->queue_request_v(info->controlQueue, entries, 1, 1, NULL);
if (status != B_OK)
return status;
acquire_sem(info->commandDone);
while (!info->virtio->queue_dequeue(info->controlQueue, NULL, NULL))
spin(10);
memcpy(response, (void*)(info->commandBuffer + cmdSize), responseSize);
if (responseHdr->fence_id != info->fenceId) {
ERROR("response fence id not right\n");
}
return B_OK;
}
status_t
virtio_gpu_get_display_info(virtio_gpu_driver_info* info)
{
CALLED();
struct virtio_gpu_ctrl_hdr hdr = {};
struct virtio_gpu_resp_display_info displayInfo = {};
hdr.type = VIRTIO_GPU_CMD_GET_DISPLAY_INFO;
virtio_gpu_send_cmd(info, &hdr, sizeof(hdr), &displayInfo, sizeof(displayInfo));
if (displayInfo.hdr.type != VIRTIO_GPU_RESP_OK_DISPLAY_INFO) {
ERROR("failed getting display info\n");
return B_ERROR;
}
if (!displayInfo.pmodes[0].enabled) {
ERROR("pmodes[0] is not enabled\n");
return B_BAD_VALUE;
}
info->displayWidth = displayInfo.pmodes[0].r.width;
info->displayHeight = displayInfo.pmodes[0].r.height;
TRACE("virtio_gpu_get_display_info width %" B_PRIu32 " height %" B_PRIu32 "\n",
info->displayWidth, info->displayHeight);
return B_OK;
}
status_t
virtio_gpu_get_edids(virtio_gpu_driver_info* info, int scanout)
{
CALLED();
struct virtio_gpu_cmd_get_edid getEdid = {};
struct virtio_gpu_resp_edid response = {};
getEdid.hdr.type = VIRTIO_GPU_CMD_GET_EDID;
getEdid.scanout = scanout;
virtio_gpu_send_cmd(info, &getEdid, sizeof(getEdid), &response, sizeof(response));
if (response.hdr.type != VIRTIO_GPU_RESP_OK_EDID) {
ERROR("failed getting edids %d\n", response.hdr.type);
return B_ERROR;
}
info->sharedInfo->has_edid = true;
memcpy(&info->sharedInfo->edid_raw, response.edid, sizeof(edid1_raw));
TRACE("virtio_gpu_get_edids success\n");
return B_OK;
}
status_t
virtio_gpu_create_2d(virtio_gpu_driver_info* info, int resourceId, int width, int height)
{
CALLED();
struct virtio_gpu_resource_create_2d resource = {};
struct virtio_gpu_ctrl_hdr response = {};
resource.hdr.type = VIRTIO_GPU_CMD_RESOURCE_CREATE_2D;
resource.resource_id = resourceId;
resource.format = VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM;
resource.width = width;
resource.height = height;
virtio_gpu_send_cmd(info, &resource, sizeof(resource), &response, sizeof(response));
if (response.type != VIRTIO_GPU_RESP_OK_NODATA) {
ERROR("viogpu_create_2d: failed %d\n", response.type);
return B_ERROR;
}
return B_OK;
}
status_t
virtio_gpu_unref(virtio_gpu_driver_info* info, int resourceId)
{
CALLED();
struct virtio_gpu_resource_unref resource = {};
struct virtio_gpu_ctrl_hdr response = {};
resource.hdr.type = VIRTIO_GPU_CMD_RESOURCE_UNREF;
resource.resource_id = resourceId;
virtio_gpu_send_cmd(info, &resource, sizeof(resource), &response, sizeof(response));
if (response.type != VIRTIO_GPU_RESP_OK_NODATA) {
ERROR("virtio_gpu_unref: failed %d\n", response.type);
return B_ERROR;
}
return B_OK;
}
status_t
virtio_gpu_attach_backing(virtio_gpu_driver_info* info, int resourceId)
{
CALLED();
struct virtio_gpu_resource_attach_backing_entries {
struct virtio_gpu_resource_attach_backing backing;
struct virtio_gpu_mem_entry entries[16];
} _PACKED backing = {};
struct virtio_gpu_ctrl_hdr response = {};
physical_entry entries[16] = {};
status_t status = get_memory_map((void*)info->framebuffer, info->framebufferSize, entries, 16);
if (status != B_OK) {
ERROR("virtio_gpu_attach_backing get_memory_map failed: %s\n", strerror(status));
return status;
}
backing.backing.hdr.type = VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING;
backing.backing.resource_id = resourceId;
for (int i = 0; i < 16; i++) {
if (entries[i].size == 0)
break;
TRACE("virtio_gpu_attach_backing %d %" B_PRIxPHYSADDR " %" B_PRIxPHYSADDR "\n", i,
entries[i].address, entries[i].size);
backing.entries[i].addr = entries[i].address;
backing.entries[i].length = entries[i].size;
backing.backing.nr_entries++;
}
virtio_gpu_send_cmd(info, &backing, sizeof(backing), &response, sizeof(response));
if (response.type != VIRTIO_GPU_RESP_OK_NODATA) {
ERROR("virtio_gpu_attach_backing failed: %d\n", response.type);
return B_ERROR;
}
return B_OK;
}
status_t
virtio_gpu_detach_backing(virtio_gpu_driver_info* info, int resourceId)
{
CALLED();
struct virtio_gpu_resource_detach_backing backing;
struct virtio_gpu_ctrl_hdr response = {};
backing.hdr.type = VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING;
backing.resource_id = resourceId;
virtio_gpu_send_cmd(info, &backing, sizeof(backing), &response, sizeof(response));
if (response.type != VIRTIO_GPU_RESP_OK_NODATA) {
ERROR("virtio_gpu_detach_backing failed: %d\n", response.type);
return B_ERROR;
}
return B_OK;
}
status_t
virtio_gpu_set_scanout(virtio_gpu_driver_info* info, int scanoutId, int resourceId,
uint32 width, uint32 height)
{
CALLED();
struct virtio_gpu_set_scanout set_scanout = {};
struct virtio_gpu_ctrl_hdr response = {};
set_scanout.hdr.type = VIRTIO_GPU_CMD_SET_SCANOUT;
set_scanout.scanout_id = scanoutId;
set_scanout.resource_id = resourceId;
set_scanout.r.width = width;
set_scanout.r.height = height;
virtio_gpu_send_cmd(info, &set_scanout, sizeof(set_scanout), &response, sizeof(response));
if (response.type != VIRTIO_GPU_RESP_OK_NODATA) {
ERROR("virtio_gpu_set_scanout failed %d\n", response.type);
return B_ERROR;
}
return B_OK;
}
status_t
virtio_gpu_transfer_to_host_2d(virtio_gpu_driver_info* info, int resourceId,
uint32 width, uint32 height)
{
struct virtio_gpu_transfer_to_host_2d transferToHost = {};
struct virtio_gpu_ctrl_hdr response = {};
transferToHost.hdr.type = VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D;
transferToHost.resource_id = resourceId;
transferToHost.r.width = width;
transferToHost.r.height = height;
virtio_gpu_send_cmd(info, &transferToHost, sizeof(transferToHost), &response,
sizeof(response));
if (response.type != VIRTIO_GPU_RESP_OK_NODATA) {
ERROR("virtio_gpu_transfer_to_host_2d failed %d\n", response.type);
return B_ERROR;
}
return B_OK;
}
status_t
virtio_gpu_flush_resource(virtio_gpu_driver_info* info, int resourceId, uint32 width,
uint32 height)
{
struct virtio_gpu_resource_flush resourceFlush = {};
struct virtio_gpu_ctrl_hdr response = {};
resourceFlush.hdr.type = VIRTIO_GPU_CMD_RESOURCE_FLUSH;
resourceFlush.resource_id = resourceId;
resourceFlush.r.width = width;
resourceFlush.r.height = height;
virtio_gpu_send_cmd(info, &resourceFlush, sizeof(resourceFlush), &response, sizeof(response));
if (response.type != VIRTIO_GPU_RESP_OK_NODATA) {
ERROR("virtio_gpu_flush_resource failed %d\n", response.type);
return B_ERROR;
}
return B_OK;
}
status_t
virtio_update_thread(void *arg)
{
virtio_gpu_driver_info* info = (virtio_gpu_driver_info*)arg;
while (info->updateThreadRunning) {
bigtime_t start = system_time();
MutexLocker commandLocker(&info->commandLock);
virtio_gpu_transfer_to_host_2d(info, info->displayResourceId, info->displayWidth,
info->displayHeight);
virtio_gpu_flush_resource(info, info->displayResourceId, info->displayWidth, info->displayHeight);
bigtime_t delay = system_time() - start;
if (delay < 20000)
snooze(20000 - delay);
}
return B_OK;
}
status_t
virtio_gpu_set_display_mode(virtio_gpu_driver_info* info, display_mode *mode)
{
CALLED();
int newResourceId = info->displayResourceId + 1;
TRACE("virtio_gpu_set_display_mode %" B_PRIu16 " %" B_PRIu16 "\n", mode->virtual_width,
mode->virtual_height);
status_t status = virtio_gpu_create_2d(info, newResourceId, mode->virtual_width, mode->virtual_height);
if (status != B_OK)
return status;
status = virtio_gpu_attach_backing(info, newResourceId);
if (status != B_OK)
return status;
status = virtio_gpu_unref(info, info->displayResourceId);
if (status != B_OK)
return status;
info->displayResourceId = newResourceId;
info->displayWidth = mode->virtual_width;
info->displayHeight = mode->virtual_height;
status = virtio_gpu_set_scanout(info, 0, 0, 0, 0);
if (status != B_OK)
return status;
status = virtio_gpu_set_scanout(info, 0, info->displayResourceId, info->displayWidth, info->displayHeight);
if (status != B_OK)
return status;
status = virtio_gpu_transfer_to_host_2d(info, info->displayResourceId, info->displayWidth, info->displayHeight);
if (status != B_OK)
return status;
status = virtio_gpu_flush_resource(info, info->displayResourceId, info->displayWidth, info->displayHeight);
if (status != B_OK)
return status;
{
virtio_gpu_shared_info& sharedInfo = *info->sharedInfo;
sharedInfo.frame_buffer_area = info->framebufferArea;
sharedInfo.frame_buffer = (uint8*)info->framebuffer;
sharedInfo.bytes_per_row = info->displayWidth * 4;
sharedInfo.current_mode.virtual_width = info->displayWidth;
sharedInfo.current_mode.virtual_height = info->displayHeight;
sharedInfo.current_mode.space = B_RGB32;
}
return B_OK;
}
static status_t
virtio_gpu_init_device(void* _info, void** _cookie)
{
CALLED();
virtio_gpu_driver_info* info = (virtio_gpu_driver_info*)_info;
device_node* parent = sDeviceManager->get_parent_node(info->node);
sDeviceManager->get_driver(parent, (driver_module_info**)&info->virtio,
(void**)&info->virtio_device);
sDeviceManager->put_node(parent);
info->virtio->negotiate_features(info->virtio_device, VIRTIO_GPU_F_EDID,
&info->features, &get_feature_name);
::virtio_queue virtioQueues[2];
status_t status = info->virtio->alloc_queues(info->virtio_device, 2,
virtioQueues, NULL);
if (status != B_OK) {
ERROR("queue allocation failed (%s)\n", strerror(status));
return status;
}
info->controlQueue = virtioQueues[0];
info->cursorQueue = virtioQueues[1];
info->commandArea = create_area("virtiogpu command buffer", (void**)&info->commandBuffer,
B_ANY_KERNEL_BLOCK_ADDRESS, B_PAGE_SIZE,
B_FULL_LOCK, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA);
if (info->commandArea < B_OK) {
status = info->commandArea;
goto err1;
}
physical_entry entry;
status = get_memory_map((void*)info->commandBuffer, B_PAGE_SIZE, &entry, 1);
if (status != B_OK)
goto err2;
info->commandPhysAddr = entry.address;
mutex_init(&info->commandLock, "virtiogpu command lock");
status = info->virtio->setup_interrupt(info->virtio_device, NULL, info);
if (status != B_OK) {
ERROR("interrupt setup failed (%s)\n", strerror(status));
goto err3;
}
status = info->virtio->queue_setup_interrupt(info->controlQueue,
virtio_gpu_vqwait, info);
if (status != B_OK) {
ERROR("queue interrupt setup failed (%s)\n", strerror(status));
goto err3;
}
*_cookie = info;
return B_OK;
err3:
err2:
delete_area(info->commandArea);
err1:
return status;
}
static void
virtio_gpu_uninit_device(void* _cookie)
{
CALLED();
virtio_gpu_driver_info* info = (virtio_gpu_driver_info*)_cookie;
info->virtio->free_interrupts(info->virtio_device);
mutex_destroy(&info->commandLock);
delete_area(info->commandArea);
info->commandArea = -1;
info->virtio->free_queues(info->virtio_device);
}
static status_t
virtio_gpu_open(void* _info, const char* path, int openMode, void** _cookie)
{
CALLED();
virtio_gpu_driver_info* info = (virtio_gpu_driver_info*)_info;
status_t status;
size_t sharedSize = (sizeof(virtio_gpu_shared_info) + 7) & ~7;
MutexLocker commandLocker;
virtio_gpu_handle* handle = (virtio_gpu_handle*)malloc(
sizeof(virtio_gpu_handle));
if (handle == NULL)
return B_NO_MEMORY;
info->commandDone = create_sem(1, "virtio_gpu_command");
if (info->commandDone < B_OK)
goto error;
info->sharedArea = create_area("virtio_gpu shared info",
(void**)&info->sharedInfo, B_ANY_KERNEL_ADDRESS,
ROUND_TO_PAGE_SIZE(sharedSize), B_FULL_LOCK,
B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA | B_CLONEABLE_AREA);
if (info->sharedArea < 0)
goto error;
memset(info->sharedInfo, 0, sizeof(virtio_gpu_shared_info));
commandLocker.SetTo(&info->commandLock, false, true);
status = virtio_gpu_get_display_info(info);
if (status != B_OK)
goto error;
if ((info->features & VIRTIO_GPU_F_EDID) != 0)
virtio_gpu_get_edids(info, 0);
info->framebufferWidth = 3840;
info->framebufferHeight = 2160;
info->framebufferSize = 4 * info->framebufferWidth * info->framebufferHeight;
info->framebufferArea = create_area("virtio_gpu framebuffer", (void**)&info->framebuffer,
B_ANY_KERNEL_ADDRESS, info->framebufferSize,
B_FULL_LOCK | B_CONTIGUOUS, B_READ_AREA | B_WRITE_AREA);
if (info->framebufferArea < B_OK) {
status = info->framebufferArea;
goto error;
}
info->displayResourceId = 1;
status = virtio_gpu_create_2d(info, info->displayResourceId, info->displayWidth,
info->displayHeight);
if (status != B_OK)
goto error;
status = virtio_gpu_attach_backing(info, info->displayResourceId);
if (status != B_OK)
goto error;
status = virtio_gpu_set_scanout(info, 0, info->displayResourceId, info->displayWidth,
info->displayHeight);
if (status != B_OK)
goto error;
{
virtio_gpu_shared_info& sharedInfo = *info->sharedInfo;
sharedInfo.frame_buffer_area = info->framebufferArea;
sharedInfo.frame_buffer = (uint8*)info->framebuffer;
sharedInfo.bytes_per_row = info->displayWidth * 4;
sharedInfo.current_mode.virtual_width = info->displayWidth;
sharedInfo.current_mode.virtual_height = info->displayHeight;
sharedInfo.current_mode.space = B_RGB32;
}
info->updateThreadRunning = true;
info->updateThread = spawn_kernel_thread(virtio_update_thread, "virtio_gpu update",
B_DISPLAY_PRIORITY, info);
if (info->updateThread < B_OK)
goto error;
resume_thread(info->updateThread);
handle->info = info;
*_cookie = handle;
return B_OK;
error:
delete_area(info->framebufferArea);
info->framebufferArea = -1;
delete_sem(info->commandDone);
info->commandDone = -1;
free(handle);
return B_ERROR;
}
static status_t
virtio_gpu_close(void* cookie)
{
virtio_gpu_handle* handle = (virtio_gpu_handle*)cookie;
CALLED();
virtio_gpu_driver_info* info = handle->info;
info->updateThreadRunning = false;
delete_sem(info->commandDone);
info->commandDone = -1;
return B_OK;
}
static status_t
virtio_gpu_free(void* cookie)
{
CALLED();
virtio_gpu_handle* handle = (virtio_gpu_handle*)cookie;
virtio_gpu_driver_info* info = handle->info;
int32 result;
wait_for_thread(info->updateThread, &result);
info->updateThread = -1;
virtio_gpu_drain_queues(info);
free(handle);
return B_OK;
}
static void
virtio_gpu_vqwait(void* driverCookie, void* cookie)
{
CALLED();
virtio_gpu_driver_info* info = (virtio_gpu_driver_info*)cookie;
release_sem_etc(info->commandDone, 1, B_DO_NOT_RESCHEDULE);
}
static status_t
virtio_gpu_read(void* cookie, off_t pos, void* buffer, size_t* _length)
{
*_length = 0;
return B_NOT_ALLOWED;
}
static status_t
virtio_gpu_write(void* cookie, off_t pos, const void* buffer,
size_t* _length)
{
*_length = 0;
return B_NOT_ALLOWED;
}
static status_t
virtio_gpu_ioctl(void* cookie, uint32 op, void* buffer, size_t length)
{
CALLED();
virtio_gpu_handle* handle = (virtio_gpu_handle*)cookie;
virtio_gpu_driver_info* info = handle->info;
switch (op) {
case B_GET_ACCELERANT_SIGNATURE:
dprintf(DEVICE_NAME ": acc: %s\n", ACCELERANT_NAME);
if (user_strlcpy((char*)buffer, ACCELERANT_NAME,
B_FILE_NAME_LENGTH) < B_OK)
return B_BAD_ADDRESS;
return B_OK;
case VIRTIO_GPU_GET_PRIVATE_DATA:
return user_memcpy(buffer, &info->sharedArea, sizeof(area_id));
case VIRTIO_GPU_SET_DISPLAY_MODE:
{
if (length != sizeof(display_mode))
return B_BAD_VALUE;
display_mode mode;
if (user_memcpy(&mode, buffer, sizeof(display_mode)) != B_OK)
return B_BAD_ADDRESS;
MutexLocker commandLocker(&info->commandLock);
return virtio_gpu_set_display_mode(info, &mode);
}
default:
ERROR("ioctl: unknown message %" B_PRIx32 "\n", op);
break;
}
return B_DEV_INVALID_IOCTL;
}
static float
virtio_gpu_supports_device(device_node* parent)
{
CALLED();
const char* bus;
uint16 deviceType;
if (sDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false))
return -1;
if (strcmp(bus, "virtio"))
return 0.0;
if (sDeviceManager->get_attr_uint16(parent, VIRTIO_DEVICE_TYPE_ITEM,
&deviceType, true) != B_OK || deviceType != VIRTIO_DEVICE_ID_GPU)
return 0.0;
TRACE("Virtio gpu device found!\n");
return 0.6;
}
static status_t
virtio_gpu_register_device(device_node* node)
{
CALLED();
device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "Virtio GPU"} },
{ NULL }
};
return sDeviceManager->register_node(node, VIRTIO_GPU_DRIVER_MODULE_NAME,
attrs, NULL, NULL);
}
static status_t
virtio_gpu_init_driver(device_node* node, void** cookie)
{
CALLED();
virtio_gpu_driver_info* info = (virtio_gpu_driver_info*)malloc(
sizeof(virtio_gpu_driver_info));
if (info == NULL)
return B_NO_MEMORY;
memset(info, 0, sizeof(*info));
info->node = node;
*cookie = info;
return B_OK;
}
static void
virtio_gpu_uninit_driver(void* _cookie)
{
CALLED();
virtio_gpu_driver_info* info = (virtio_gpu_driver_info*)_cookie;
free(info);
}
static status_t
virtio_gpu_register_child_devices(void* _cookie)
{
CALLED();
virtio_gpu_driver_info* info = (virtio_gpu_driver_info*)_cookie;
status_t status;
int32 id = sDeviceManager->create_id(VIRTIO_GPU_DEVICE_ID_GENERATOR);
if (id < 0)
return id;
char name[64];
snprintf(name, sizeof(name), "graphics/virtio/%" B_PRId32,
id);
status = sDeviceManager->publish_device(info->node, name,
VIRTIO_GPU_DEVICE_MODULE_NAME);
return status;
}
module_dependency module_dependencies[] = {
{B_DEVICE_MANAGER_MODULE_NAME, (module_info**)&sDeviceManager},
{}
};
struct device_module_info sVirtioGpuDevice = {
{
VIRTIO_GPU_DEVICE_MODULE_NAME,
0,
NULL
},
virtio_gpu_init_device,
virtio_gpu_uninit_device,
NULL,
virtio_gpu_open,
virtio_gpu_close,
virtio_gpu_free,
virtio_gpu_read,
virtio_gpu_write,
NULL,
virtio_gpu_ioctl,
NULL,
NULL,
};
struct driver_module_info sVirtioGpuDriver = {
{
VIRTIO_GPU_DRIVER_MODULE_NAME,
0,
NULL
},
virtio_gpu_supports_device,
virtio_gpu_register_device,
virtio_gpu_init_driver,
virtio_gpu_uninit_driver,
virtio_gpu_register_child_devices,
NULL,
NULL,
};
module_info* modules[] = {
(module_info*)&sVirtioGpuDriver,
(module_info*)&sVirtioGpuDevice,
NULL
};
