Mercurial Mercurial > oss > MCL > sf > adapt > qemu / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
symbian-qemu-0.9.1-12/qemu-symbian-svp/plugins/syborg_graphicsdevice.py
branchgraphics-phase-3
changeset 99 542d4bc8b7ca
parent 77 b3dcdc7f8f12
equal deleted inserted replaced
98:23e14cbcf117 99:542d4bc8b7ca 
       
     1 #
 
       
     2 # Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
 
       
     3 # All rights reserved.
 
       
     4 # This component and the accompanying materials are made available
 
       
     5 # under the terms of "Eclipse Public License v1.0"
 
       
     6 # which accompanies this distribution, and is available
 
       
     7 # at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
       
     8 #
 
       
     9 # Initial Contributors:
 
       
    10 # Nokia Corporation - initial contribution.
 
       
    11 #
 
       
    12 # Contributors:
 
       
    13 #
 
       
    14 # Description: syborg_graphicsdevice.py
 
       
    15 #
 
       
    16 # Represents a graphics device register interface for quest OS in QEMU Syborg environment.
 
       
    17 #
 
       
    18 #
 
       
    19 
     1 import ctypes
 
    20 import ctypes
 
     2 import qemu
 
    21 import qemu
 
     3 import sys
 
    22 import sys
 
     4 #import SyborgModule
 
    23 import platform
 
     5 
    24 
     6 class syborg_graphicsdevice(qemu.devclass):
 
    25 class syborg_graphicsdevice(qemu.devclass):
 
     7     # Graphics device registers derived from VirtualVideoInterfaceConstants.h
 
    26     # Graphics device registers derived from VirtualVideoInterfaceConstants.h
 
     8     VVI_R_ID                                = 0x0000
 
    27     VVI_R_ID                                = 0x0000
 
     9     VVI_R_IRQ_ENABLE                        = 0x0004
 
    28     VVI_R_IRQ_ENABLE                        = 0x0004
 
    24     VVI_EXECUTE                             = 0
 
    43     VVI_EXECUTE                             = 0
 
    25     shared_cmd_memory_base                  = 0
 
    44     shared_cmd_memory_base                  = 0
 
    26     shared_framebuffer_memory_base          = 0
 
    45     shared_framebuffer_memory_base          = 0
 
    27     m_request_id_reg = 0
 
    46     m_request_id_reg = 0
 
    28 
    47 
    29     # Memory base id's from SyborgModule.h
 
    48     host_os                             = platform.system()
 
    30     # SYBORG_CMDMEMBASE = 0
 
    49     # List of operating systems for this device
 
    31     # SYBORG_FRAMEBUFFERMEMBASE = 1
 
    50     OS_WINDOWS                          = "Windows"
 
    32     
    51     OS_LINUX                            = "Linux"
 
    33     class DllLoadExeption( Exception ):
 
       
    34         def __init__(self,value):
 
       
    35             self.value = value
 
       
    36         
       
    37         def __str__(self):
 
       
    38             return repr(self.value)
 
       
    39 
       
    40     class SyborgGraphicsWrapper():
 
       
    41         def __init__(self):
 
       
    42             try:
 
       
    43                 self.library = ctypes.CDLL("syborg-graphicswrapper.dll")
 
       
    44             except:
 
       
    45                 raise syborg_graphicsdevice.DllLoadExeption(1)
 
       
    46             self.obj = self.library.create_SyborgGraphicsWrapper()
 
       
    47 
       
    48         def initialize_graphics_utils(self):
 
       
    49             self.library.initialize_SyborgGraphicsWrapper( self.obj )
 
       
    50 
    52 
    51     def create(self):
 
    53     def create(self):
 
       
    54         print "syborg_graphicsdevice: running on ", self.host_os
 
       
    55         
       
    56         # Add the supported and validated operating systems to the condition below
 
       
    57         if( (self.host_os != self.OS_WINDOWS) ):
 
       
    58             error_msg = "syborg_graphicsdevice: os support not validated: ", self.host_os
 
       
    59             sys.exit( error_msg )
 
       
    60 
       
    61         # Try open the syborg graphicswrapper library
 
    52         try:
 
    62         try:
 
    53             self.graphicsutils = self.SyborgGraphicsWrapper()
 
    63             if( self.host_os == self.OS_WINDOWS ):
 
    54         except syborg_graphicsdevice.DllLoadExeption:
 
    64                 libname = "syborg-graphicswrapper.dll"
 
    55             #print "syborg_graphicsdevice: Graphics dll load failed"
 
    65             elif( self.host_os == self.OS_LINUX ):
 
    56             sys.exit("syborg_graphicsdevice: Graphics dll load failed")
 
    66                 libname = "syborg-graphicswrapper.so"
 
       
    67             else:
 
       
    68                 # We should never end up here since the operating system check is done above
 
       
    69                 sys.exit( "syborg_graphicsdevice: library loading failed. Os not supported!" )
 
       
    70             self.library = ctypes.CDLL(libname)
 
       
    71         except Exception, e:
 
       
    72             print repr(e)
 
       
    73             error_msg = "syborg_graphicsdevice: " + libname + " load failed";
 
       
    74             sys.exit( error_msg )
 
       
    75 
       
    76         # Create an instance of syborg graphics wrapper
 
       
    77         self.obj = self.library.create_SyborgGraphicsWrapper()
 
    57             
    78             
    58             
    79         self.library.initialize_SyborgGraphicsWrapper( self.obj )
 
    59         self.graphicsutils.initialize_graphics_utils()
 
       
    60         self.initialize_graphics_callback()
 
    80         self.initialize_graphics_callback()
 
    61         # deliver the graphics ram region
 
       
    62         # self.gmembase = self.graphicsutils.library.get_membase()
 
       
    63 
    81 
    64         self.irqenable = 0
 
    82         self.irqenable = 0
 
    65         self.irqstatus = 0
 
    83         self.irqstatus = 0
 
    66         self.command = 0
 
    84         self.command = 0
 
    67         self.parameterload = 0
 
    85         self.parameterload = 0
 
    76         return 0
 
    94         return 0
 
    77         
    95         
    78     def initialize_graphics_callback(self):
 
    96     def initialize_graphics_callback(self):
 
    79         self.CALLBACKFUNC = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int)
 
    97         self.CALLBACKFUNC = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int)
 
    80         self.graphics_callback = self.CALLBACKFUNC(self.graphics_request_callback)
 
    98         self.graphics_callback = self.CALLBACKFUNC(self.graphics_request_callback)
 
    81         self.graphicsutils.library.set_GraphicsCallBack( self.graphicsutils.obj, self.graphics_callback )
 
    99         self.library.set_GraphicsCallBack( self.obj, self.graphics_callback )
 
    82             
   100             
    83     def read_reg(self, offset):
 
   101     def read_reg(self, offset):
 
    84         offset >>= 2
 
   102         offset >>= 2
 
    85         if offset == self.VVI_R_ID:
 
   103         if offset == self.VVI_R_ID:
 
    86             return 0xDEADBEEF
 
   104             return 0xDEADBEEF
 
    94             return self.parameterload
 
   112             return self.parameterload
 
    95         elif offset == self.VVI_R_ERROR:
 
   113         elif offset == self.VVI_R_ERROR:
 
    96             self.lasterror = 0
 
   114             self.lasterror = 0
 
    97             return self.lasterror
 
   115             return self.lasterror
 
    98         elif offset == self.VVI_R_INPUT_BUFFER_TAIL:
 
   116         elif offset == self.VVI_R_INPUT_BUFFER_TAIL:
 
    99             return self.graphicsutils.library.get_InputBufferTail( self.graphicsutils.obj )
 
   117             return self.library.get_InputBufferTail( self.obj )
 
   100         elif offset == self.VVI_R_INPUT_BUFFER_HEAD:
 
   118         elif offset == self.VVI_R_INPUT_BUFFER_HEAD:
 
   101             return self.graphicsutils.library.get_InputBufferHead( self.graphicsutils.obj )
 
   119             return self.library.get_InputBufferHead( self.obj )
 
   102         elif offset == self.VVI_R_INPUT_BUFFER_READ_COUNT:
 
   120         elif offset == self.VVI_R_INPUT_BUFFER_READ_COUNT:
 
   103             return self.graphicsutils.library.get_InputBufferReadCount( self.graphicsutils.obj )
 
   121             return self.library.get_InputBufferReadCount( self.obj )
 
   104         elif offset == self.VVI_R_INPUT_BUFFER_WRITE_COUNT:
 
   122         elif offset == self.VVI_R_INPUT_BUFFER_WRITE_COUNT:
 
   105             return self.graphicsutils.library.get_InputBufferWriteCount( self.graphicsutils.obj )
 
   123             return self.library.get_InputBufferWriteCount( self.obj )
 
   106         elif offset == self.VVI_R_INPUT_BUFFER_MAX_TAIL:
 
   124         elif offset == self.VVI_R_INPUT_BUFFER_MAX_TAIL:
 
   107             return self.graphicsutils.library.get_InputMaxTailIndex( self.graphicsutils.obj )
 
   125             return self.library.get_InputMaxTailIndex( self.obj )
 
   108         elif offset == self.VVI_R_REQUEST_ID:
 
   126         elif offset == self.VVI_R_REQUEST_ID:
 
   109             return self.m_request_id_reg
 
   127             return self.m_request_id_reg
 
   110         elif offset == self.VVI_R_SHARED_CMD_MEMORY_BASE:
 
   128         elif offset == self.VVI_R_SHARED_CMD_MEMORY_BASE:
 
   111             return self.shared_cmd_memory_base
 
   129             return self.shared_cmd_memory_base
 
   112         elif offset == self.VVI_R_SHARED_FRAMEBUFFER_MEMORY_BASE:
 
   130         elif offset == self.VVI_R_SHARED_FRAMEBUFFER_MEMORY_BASE:
 
   117 
   135 
   118     def write_reg(self, offset, value):
 
   136     def write_reg(self, offset, value):
 
   119         offset >>= 2
 
   137         offset >>= 2
 
   120         if offset == self.VVI_R_IRQ_STATUS:
 
   138         if offset == self.VVI_R_IRQ_STATUS:
 
   121             self.updateIrq(0);
 
   139             self.updateIrq(0);
 
   122             self.graphicsutils.library.signal_outputbuffer_semafore( self.graphicsutils.obj )
 
   140             self.library.signal_outputbuffer_semafore( self.obj )
 
   123             self.graphicsutils.library.execute_command( self.graphicsutils.obj );
 
   141             self.library.execute_command( self.obj );
 
   124         elif offset == self.VVI_R_COMMAND:
 
   142         elif offset == self.VVI_R_COMMAND:
 
   125             if value == self.VVI_EXECUTE:
 
   143             if value == self.VVI_EXECUTE:
 
   126                 self.graphicsutils.library.execute_command( self.graphicsutils.obj );
 
   144                 self.library.execute_command( self.obj );
 
   127             else:
 
   145             else:
 
   128                 sys.exit("syborg_graphicsdevice: Unknown command issued!")
 
   146                 sys.exit("syborg_graphicsdevice: Unknown command issued!")
 
   129         elif offset == self.VVI_R_INPUT_BUFFER_TAIL:
 
   147         elif offset == self.VVI_R_INPUT_BUFFER_TAIL:
 
   130             self.graphicsutils.library.set_InputBufferTail(  self.graphicsutils.obj, value );
 
   148             self.library.set_InputBufferTail(  self.obj, value );
 
   131         elif offset == self.VVI_R_INPUT_BUFFER_HEAD:
 
   149         elif offset == self.VVI_R_INPUT_BUFFER_HEAD:
 
   132             self.graphicsutils.library.set_InputBufferHead( self.graphicsutils.obj, value );
 
   150             self.library.set_InputBufferHead( self.obj, value );
 
   133         elif offset == self.VVI_R_INPUT_BUFFER_READ_COUNT:
 
   151         elif offset == self.VVI_R_INPUT_BUFFER_READ_COUNT:
 
   134             self.graphicsutils.library.set_InputBufferReadCount( self.graphicsutils.obj, value );
 
   152             self.library.set_InputBufferReadCount( self.obj, value );
 
   135         elif offset == self.VVI_R_INPUT_BUFFER_WRITE_COUNT:
 
   153         elif offset == self.VVI_R_INPUT_BUFFER_WRITE_COUNT:
 
   136             self.graphicsutils.library.set_InputBufferWriteCount( self.graphicsutils.obj, value );
 
   154             self.library.set_InputBufferWriteCount( self.obj, value );
 
   137         elif offset == self.VVI_R_INPUT_BUFFER_MAX_TAIL:
 
   155         elif offset == self.VVI_R_INPUT_BUFFER_MAX_TAIL:
 
   138             self.graphicsutils.library.set_InputMaxTailIndex( self.graphicsutils.obj, value );
 
   156             self.library.set_InputMaxTailIndex( self.obj, value );
 
   139         elif offset == self.VVI_R_SHARED_CMD_MEMORY_BASE:
 
   157         elif offset == self.VVI_R_SHARED_CMD_MEMORY_BASE:
 
   140             gmemsize = self.graphicsutils.library.get_cmd_memsize()
 
   158             gmemsize = self.library.get_cmd_memsize()
 
   141             self.cmd_memregion = qemu.memregion( value, gmemsize )
 
   159             self.cmd_memregion = qemu.memregion( value, gmemsize )
 
   142             self.memregion_cmd_base = self.cmd_memregion.region_host_addr()
 
   160             self.memregion_cmd_base = self.cmd_memregion.region_host_addr()
 
   143             #SyborgModule.post_address( self.memregion_cmd_base, self.SYBORG_CMDMEMBASE )
 
       
   144         elif offset == self.VVI_R_SHARED_FRAMEBUFFER_MEMORY_BASE:
 
   161         elif offset == self.VVI_R_SHARED_FRAMEBUFFER_MEMORY_BASE:
 
   145             gmemsize = self.graphicsutils.library.get_framebuffer_memsize()
 
   162             gmemsize = self.library.get_framebuffer_memsize()
 
   146             self.framebuffer_memregion = qemu.memregion( value, gmemsize )
 
   163             self.framebuffer_memregion = qemu.memregion( value, gmemsize )
 
   147             self.memregion_framebuffer_base = self.framebuffer_memregion.region_host_addr()
 
   164             self.memregion_framebuffer_base = self.framebuffer_memregion.region_host_addr()
 
   148             #SyborgModule.post_address( self.memregion_framebuffer_base, self.SYBORG_FRAMEBUFFERMEMBASE )
 
       
   149             # Ready to finalise graphics initialization
 
   165             # Ready to finalise graphics initialization
 
   150             if( self.graphicsutils.library.reset_SyborgGraphicsWrapper( self.graphicsutils.obj, self.memregion_framebuffer_base, self.memregion_cmd_base ) != 0 ):
 
   166             if( self.library.reset_SyborgGraphicsWrapper( self.obj, self.memregion_framebuffer_base, self.memregion_cmd_base ) != 0 ):
 
   151                 sys.exit("syborg_graphicsdevice: Syborg graphicsutils library not initialized correctly!")
 
   167                 sys.exit("syborg_graphicsdevice: Syborg graphicsutils library not initialized correctly!")
 
   152         else:
 
   168         else:
 
   153             reg_write_error = "syborg_graphicsdevice: Illegal register write to: ", offset 
   169             reg_write_error = "syborg_graphicsdevice: Illegal register write to: ", offset 
   154             sys.exit( reg_write_error )
 
   170             sys.exit( reg_write_error )
 
   155 
   171
MCL/sf/adapt/qemu