import ctypes

import qemu

import sys

class syborg_graphicsdevice(qemu.devclass):

    # Graphics device registers derived from VirtualVideoInterfaceConstants.h

    VVI_R_ID                                = 0x0000

    VVI_R_IRQ_ENABLE                        = 0x0004

    VVI_R_IRQ_STATUS                        = 0x0008

    VVI_R_COMMAND                           = 0x000c

    VVI_R_PARAMETER_LOAD                    = 0x0010

    VVI_R_ERROR                             = 0x0014

    VVI_R_INPUT_BUFFER_TAIL                 = 0x0018

    VVI_R_INPUT_BUFFER_HEAD                 = 0x001c

    VVI_R_INPUT_BUFFER_READ_COUNT           = 0x0020

    VVI_R_INPUT_BUFFER_WRITE_COUNT          = 0x0024

    VVI_R_INPUT_BUFFER_MAX_TAIL             = 0x0028

    VVI_R_REQUEST_ID                        = 0x002c

    VVI_R_SHARED_CMD_MEMORY_BASE            = 0x0030

    VVI_R_SHARED_FRAMEBUFFER_MEMORY_BASE    = 0x0034

    VVI_R_LASTREG                           = 0x0038  # not a register, address of last register

    VVI_EXECUTE                             = 0

    shared_cmd_memory_base                  = 0

    shared_framebuffer_memory_base          = 0

    m_request_id_reg = 0

    def create(self):

        try:

        self.initialize_graphics_callback()

        self.irqenable = 0

        self.irqstatus = 0

        self.command = 0

        self.parameterload = 0

    def updateIrq(self,new_value):

        self.set_irq_level(0, new_value)

    def graphics_request_callback(self, request_id):

        #print "graphics_request_callback: " , request_id

        self.m_request_id_reg = request_id

        self.updateIrq(1)

        return 0

    def initialize_graphics_callback(self):

        self.CALLBACKFUNC = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int)

        self.graphics_callback = self.CALLBACKFUNC(self.graphics_request_callback)

    def read_reg(self, offset):

        offset >>= 2

        if offset == self.VVI_R_ID:

            return 0xDEADBEEF

        elif offset == self.VVI_R_IRQ_ENABLE:

            return self.irqenable

        elif offset == self.VVI_R_IRQ_STATUS:

            return self.irqstatus

        elif offset == self.VVI_R_COMMAND:

            return self.command

        elif offset == self.VVI_R_PARAMETER_LOAD:

            return self.parameterload

        elif offset == self.VVI_R_ERROR:

            self.lasterror = 0

            return self.lasterror

        elif offset == self.VVI_R_INPUT_BUFFER_TAIL:

        elif offset == self.VVI_R_INPUT_BUFFER_HEAD:

        elif offset == self.VVI_R_INPUT_BUFFER_READ_COUNT:

        elif offset == self.VVI_R_INPUT_BUFFER_WRITE_COUNT:

        elif offset == self.VVI_R_INPUT_BUFFER_MAX_TAIL:

        elif offset == self.VVI_R_REQUEST_ID:

            return self.m_request_id_reg

        elif offset == self.VVI_R_SHARED_CMD_MEMORY_BASE:

            return self.shared_cmd_memory_base

        elif offset == self.VVI_R_SHARED_FRAMEBUFFER_MEMORY_BASE:

            return self.shared_framebuffer_memory_base

        else:

            reg_read_error = "syborg_graphicsdevice: Illegal register read at: ", offset 

            sys.exit( reg_read_error )

    def write_reg(self, offset, value):

        offset >>= 2

        if offset == self.VVI_R_IRQ_STATUS:

            self.updateIrq(0);

        elif offset == self.VVI_R_COMMAND:

            if value == self.VVI_EXECUTE:

            else:

                sys.exit("syborg_graphicsdevice: Unknown command issued!")

        elif offset == self.VVI_R_INPUT_BUFFER_TAIL:

        elif offset == self.VVI_R_INPUT_BUFFER_HEAD:

        elif offset == self.VVI_R_INPUT_BUFFER_READ_COUNT:

        elif offset == self.VVI_R_INPUT_BUFFER_WRITE_COUNT:

        elif offset == self.VVI_R_INPUT_BUFFER_MAX_TAIL:

        elif offset == self.VVI_R_SHARED_CMD_MEMORY_BASE:

            self.cmd_memregion = qemu.memregion( value, gmemsize )

            self.memregion_cmd_base = self.cmd_memregion.region_host_addr()

        elif offset == self.VVI_R_SHARED_FRAMEBUFFER_MEMORY_BASE:

            self.framebuffer_memregion = qemu.memregion( value, gmemsize )

            self.memregion_framebuffer_base = self.framebuffer_memregion.region_host_addr()

            # Ready to finalise graphics initialization

                sys.exit("syborg_graphicsdevice: Syborg graphicsutils library not initialized correctly!")

        else:

            reg_write_error = "syborg_graphicsdevice: Illegal register write to: ", offset 

            sys.exit( reg_write_error )

    # Device class properties

    regions = [qemu.ioregion(0x1000, readl=read_reg, writel=write_reg)]

    irqs = 1

    name = "syborg,graphicsdevice"

    properties = {}

qemu.register_device(syborg_graphicsdevice)