diff -r 345f1c88c950 -r b6c206049d8a symbian-qemu-0.9.1-12/model-libraries/nvmemmory/nvmemmory.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/model-libraries/nvmemmory/nvmemmory.cpp	Wed Sep 22 17:06:27 2010 +0100
@@ -0,0 +1,267 @@
+/*
+* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+* Simple non volatile memory device. nvmemmory.cpp
+*
+*/
+
+extern "C" 
+    {
+#include <stdio.h>
+    }
+#include "nvmemmory.h"
+
+SyborgNVMemory::SyborgNVMemory( uint32_t a_sectorsize ):
+    iNVMemSectorSizeInBytes( a_sectorsize )
+    {
+    for( int32_t index = 0; index < NVMEM_MAX_STREAMHANDLES; index += 1 ) 
+        {
+        i_filestream[index] = NULL;
+        }
+    }
+
+SyborgNVMemory::~SyborgNVMemory()
+    {
+    NVMemReset();
+    }
+
+int32_t SyborgNVMemory::NVMemReset( )
+    {
+    /*Initialize the file array*/
+    for( int32_t index = 0; index < NVMEM_MAX_STREAMHANDLES; index += 1 ) 
+        {
+        if( i_filestream[index] != NULL )
+            {
+            fclose( i_filestream[index] );
+            i_filestream[index] = NULL;
+            }
+        }
+    return 0;
+    }
+
+int32_t SyborgNVMemory::NVMemCreateImage( char* a_memoryarrayname, uint32_t a_sectorcount, uint32_t a_sectorsize )
+    {
+    /* Create a temporary MByte buffer array for image creation purpose */
+    const uint32_t tempbufsize = 1024 * 1024;
+    uint8_t tempbuf[ tempbufsize ];
+    uint32_t index = 0;
+    FILE *filestream = NULL;
+    char mode1[4] = {"rb"};
+    char mode2[4] = {"wb"};
+    int32_t ret = NVMEM_ERROR_CREATE;
+    uint32_t temparraysectorcount = tempbufsize / a_sectorsize;
+    iNVMemSectorSizeInBytes = a_sectorsize;
+            
+    /* Try to open the specified file. If it exists we do not create a new one */
+    filestream = fopen( a_memoryarrayname, &mode1[0] );
+    if( filestream == NULL )
+        {
+        /* Fill MBR with zeroes */
+        for( index = 0; index < iNVMemSectorSizeInBytes; index += 1 )
+            {
+            tempbuf[index] = 0;
+            }
+        /* Open a temporary file handle. Create the file*/
+        filestream = fopen( a_memoryarrayname, &mode2[0] );
+
+        if( ret != NULL )
+            {
+            ret = NVMEM_OK;
+            for( index = 0; (index < a_sectorcount) && (ret == NVMEM_OK); index += temparraysectorcount )
+                {
+                /* Print one array of zeroes to our temporary buffer */
+                if( fwrite( tempbuf, iNVMemSectorSizeInBytes, temparraysectorcount, filestream ) < 0 )
+                    {
+                    ret = NVMEM_ERROR_FWRITE;
+                    }
+                }
+            fclose( filestream );
+            }
+        else
+            {
+            ret = NVMEM_ERROR_FOPEN;
+            }
+        }
+    return ret;
+    }
+
+int32_t SyborgNVMemory::NVMemOpen( char* a_memoryarrayname )
+    {
+    char mode[4] = {"rb+"};
+    int32_t handle = NVMEM_ERROR_OUT_OF_FREE_STREAMHANDLES;
+    /* Search for a free handle position and assign if found */
+    int32_t index = 0;
+    for( ; index < NVMEM_MAX_STREAMHANDLES; index += 1 ) 
+        {
+        if( i_filestream[index] == NULL )
+            {
+            i_filestream[index] = fopen( a_memoryarrayname, &mode[0] );
+            if( i_filestream[index] != NULL )
+                {
+                handle = index;
+                printf("handle created: %d\n", index);
+                }
+            else
+                {
+                handle = NVMEM_ERROR_FOPEN;
+                }
+            break;
+            }
+        }
+    return handle;
+    }
+
+int32_t SyborgNVMemory::NVMemClose( int32_t a_memoryarrayhandle )
+    {
+    int32_t result = NVMEM_ERROR_FCLOSE;
+    if( fclose( i_filestream[a_memoryarrayhandle] ) == 0 )
+        {
+        result = NVMEM_OK;
+        }
+    return result;
+    }
+
+int32_t SyborgNVMemory::NVMemFlush( int32_t a_memoryarrayhandle )
+    {
+    int32_t result = NVMEM_ERROR_FFLUSH;
+    if( fflush( i_filestream[a_memoryarrayhandle] ) == 0 )
+        {
+        result = NVMEM_OK;
+        }
+    return result;
+    }
+
+void SyborgNVMemory::NVMemRead( uint32_t *a_client_targetmemoryaddr, int32_t a_memoryarrayhandle, uint32_t a_memoryarraysectoroffset, uint32_t a_sectorcount )
+    {
+    //printf("SyborgNVMemory::NVMemRead: sectorpos:%d sectorcount:%d hostaddr: 0x%08x handle: %d\n", a_memoryarraysectoroffset, a_sectorcount, a_client_targetmemoryaddr, a_memoryarrayhandle );
+    uint32_t items_read = 0;
+    long streamoffset = a_memoryarraysectoroffset * iNVMemSectorSizeInBytes;
+    int32_t result = fseek( i_filestream[a_memoryarrayhandle], streamoffset, SEEK_SET );
+    if( result == 0 )   
+        {
+        items_read = fread( a_client_targetmemoryaddr, iNVMemSectorSizeInBytes, a_sectorcount, i_filestream[a_memoryarrayhandle] );
+        /*Check that everything is read*/
+        if( items_read != a_sectorcount )
+            {
+            result = NVMEM_ERROR_FREAD;
+            }
+        else
+            {
+            result = items_read;
+            }
+        }
+    else /*error*/
+        {
+        result = NVMEM_ERROR_FSEEK;
+        }
+    i_NVMemCallBack( result );
+    }
+
+void SyborgNVMemory::NVMemWrite( uint32_t *a_client_sourcememoryaddr, int32_t a_memoryarrayhandle, uint32_t a_memoryarraysectoroffset, uint32_t a_sectorcount )
+    {
+    //printf("SyborgNVMemory::NVMemWrite: sectorpos:%d sectorcount:%d hostaddr: 0x%08x\n", a_memoryarraysectoroffset, a_sectorcount, a_client_sourcememoryaddr );
+    uint32_t items_written = 0;
+    long streamoffset = a_memoryarraysectoroffset * iNVMemSectorSizeInBytes;
+    int32_t result = fseek( i_filestream[a_memoryarrayhandle], streamoffset, SEEK_SET );
+    if( result == 0 )   
+        {
+        items_written = fwrite( a_client_sourcememoryaddr, iNVMemSectorSizeInBytes, a_sectorcount, i_filestream[a_memoryarrayhandle] );
+        /*Check that everything is written*/
+        if( items_written != a_sectorcount )
+            {
+            result = NVMEM_ERROR_FWRITE;
+            }
+        else
+            {
+            result = items_written;
+            }
+        }
+    else /*error*/
+        {
+        result = NVMEM_ERROR_FSEEK;
+        }
+    i_NVMemCallBack( result );
+    }
+
+uint32_t SyborgNVMemory::NVMemGetSectorCount( int32_t a_memoryarrayhandle )
+    {
+    long byte_size = 0;
+    uint32_t sector_count = 0;
+    printf("use handle: %d\n", a_memoryarrayhandle);
+    fseek( i_filestream[a_memoryarrayhandle], 0, SEEK_END );
+    byte_size = ftell( i_filestream[a_memoryarrayhandle] );
+    sector_count = byte_size / iNVMemSectorSizeInBytes;
+    return sector_count;
+    }
+
+int32_t  SyborgNVMemory::NVMemSetCallback( int (*aNVMemCallBack) (int) )
+    {
+    i_NVMemCallBack = aNVMemCallBack;
+    return 0;
+    }
+
+
+extern "C"
+    {
+    NVMEMORY_API SyborgNVMemory * nvmem_create( uint32_t a_sectorsize )
+        {
+        return new SyborgNVMemory( a_sectorsize );
+        }
+
+    NVMEMORY_API int32_t nvmem_reset( SyborgNVMemory* a_syborg_nvmemory ) 
+        {
+        return a_syborg_nvmemory->NVMemReset();
+        }
+
+    NVMEMORY_API int32_t nvmem_create_image( SyborgNVMemory* a_syborg_nvmemory, char* a_memoryarrayname, uint32_t a_sectorcount, uint32_t a_sectorsize )
+        {
+        return a_syborg_nvmemory->NVMemCreateImage( a_memoryarrayname, a_sectorcount, a_sectorsize );
+        }
+
+    NVMEMORY_API int32_t nvmem_open( SyborgNVMemory* a_syborg_nvmemory, char* a_memoryarrayname ) 
+        {
+        return a_syborg_nvmemory->NVMemOpen( a_memoryarrayname );
+        }
+
+    NVMEMORY_API int32_t nvmem_close( SyborgNVMemory* a_syborg_nvmemory, int32_t a_memoryarrayhandle ) 
+        {
+        return a_syborg_nvmemory->NVMemClose( a_memoryarrayhandle );
+        }
+
+    NVMEMORY_API int32_t nvmem_flush( SyborgNVMemory* a_syborg_nvmemory, int32_t a_memoryarrayhandle ) 
+        {
+        return a_syborg_nvmemory->NVMemFlush( a_memoryarrayhandle );
+        }
+
+    NVMEMORY_API void nvmem_read( SyborgNVMemory* a_syborg_nvmemory, uint32_t *a_client_targetmemoryaddr, int32_t a_memoryarrayhandle, uint32_t a_memoryarraysectoroffset, uint32_t a_sectorcount ) 
+        {
+        a_syborg_nvmemory->NVMemRead( a_client_targetmemoryaddr, a_memoryarrayhandle, a_memoryarraysectoroffset, a_sectorcount );
+        }
+
+    NVMEMORY_API void nvmem_write( SyborgNVMemory* a_syborg_nvmemory, uint32_t *a_client_sourcememoryaddr, int32_t a_memoryarrayhandle, uint32_t a_memoryarraysectoroffset, uint32_t a_sectorcount ) 
+        {
+        a_syborg_nvmemory->NVMemWrite( a_client_sourcememoryaddr, a_memoryarrayhandle, a_memoryarraysectoroffset, a_sectorcount );
+        }
+
+    NVMEMORY_API uint32_t nvmem_get_sector_count( SyborgNVMemory* a_syborg_nvmemory, int32_t a_memoryarrayhandle )
+        {
+        return a_syborg_nvmemory->NVMemGetSectorCount( a_memoryarrayhandle );
+        }
+    
+    NVMEMORY_API int32_t nvmem_set_callback( SyborgNVMemory* a_syborg_nvmemory, int (*aGraphicsCallBack) (int) )
+        {
+        return a_syborg_nvmemory->NVMemSetCallback( aGraphicsCallBack );
+        }
+    }