/*
 * 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"
//#define TRACE_VIRTIO_GPU
#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;

        // create framebuffer area
        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;
}


//      #pragma mark - device module API


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);

        // TODO read config

        // Setup queues
        ::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];

        // create command buffer area
        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");

        // Setup interrupt
        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);

        // so we can fit every mode
        info->framebufferWidth = 3840;
        info->framebufferHeight = 2160;

        // create framebuffer area
        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;

        // TRACE("ioctl(op = %lx)\n", op);

        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;

                // needed to share data between kernel and accelerant
                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;
}


//      #pragma mark - driver module API


static float
virtio_gpu_supports_device(device_node* parent)
{
        CALLED();
        const char* bus;
        uint16 deviceType;

        // make sure parent is really the Virtio bus manager
        if (sDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false))
                return -1;

        if (strcmp(bus, "virtio"))
                return 0.0;

        // check whether it's really a Virtio GPU device
        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;
}


//      #pragma mark -


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, // remove,

        virtio_gpu_open,
        virtio_gpu_close,
        virtio_gpu_free,
        virtio_gpu_read,
        virtio_gpu_write,
        NULL,   // io
        virtio_gpu_ioctl,

        NULL,   // select
        NULL,   // deselect
};

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,   // rescan
        NULL,   // removed
};

module_info* modules[] = {
        (module_info*)&sVirtioGpuDriver,
        (module_info*)&sVirtioGpuDevice,
        NULL
};