From 9c88e4d06731c7d7812b6abfec9cda36cf446d1c Mon Sep 17 00:00:00 2001 From: Atheria Date: Sun, 7 Sep 2025 07:07:17 +0700 Subject: [PATCH 1/4] RW lock improvements, EXT delete --- fs/EXT/Ext2.c | 436 ++++++++++++++++++++++++++++++++++----- kernel/atomic/Spinlock.h | 29 ++- kernel/sched/MLFQ.c | 10 +- 3 files changed, 415 insertions(+), 60 deletions(-) diff --git a/fs/EXT/Ext2.c b/fs/EXT/Ext2.c index ae01a6a..e88c035 100644 --- a/fs/EXT/Ext2.c +++ b/fs/EXT/Ext2.c @@ -5,6 +5,8 @@ #include "../../mm/KernelHeap.h" #include "../../mm/MemOps.h" #include "../../kernel/etc/StringOps.h" +#include "../../kernel/atomic/Spinlock.h" +#include "../../kernel/sched/MLFQ.h" #define EXT2_SUPERBLOCK_OFFSET 1024 #define EXT2_MAGIC 0xEF53 @@ -18,6 +20,7 @@ typedef struct { uint32_t num_groups; Ext2Superblock superblock; Ext2GroupDesc* group_descs; + rwlock_t lock; } Ext2Volume; static Ext2Volume volume; @@ -25,9 +28,11 @@ int ext2_initialized = 0; // Helper to read a block from the disk int Ext2ReadBlock(uint32_t block, void* buffer) { + ReadLock(&volume.lock, MLFQGetCurrentProcess()->pid); if (block >= volume.superblock.s_blocks_count) { PrintKernelF("[EXT2] Block %u out of bounds (max: %u)", block, volume.superblock.s_blocks_count - 1); + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return -1; } uint32_t sector_start = block * (volume.block_size / 512); @@ -36,17 +41,21 @@ int Ext2ReadBlock(uint32_t block, void* buffer) { if (IdeReadSector(volume.drive, sector_start + i, (uint8_t*)buffer + (i * 512)) != IDE_OK) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return -1; } } + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return 0; } static int Ext2WriteBlock(uint32_t block, const void* buffer) { + WriteLock(&volume.lock, MLFQGetCurrentProcess()->pid); if (block >= volume.superblock.s_blocks_count) { PrintKernelF("[EXT2] Block %u out of bounds (max: %u)\ ", block, volume.superblock.s_blocks_count - 1); + WriteUnlock(&volume.lock); return -1; } uint32_t sector_start = block * (volume.block_size / 512); @@ -55,16 +64,22 @@ static int Ext2WriteBlock(uint32_t block, const void* buffer) { if (IdeWriteSector(volume.drive, sector_start + i, (uint8_t*)buffer + (i * 512)) != IDE_OK) { + WriteUnlock(&volume.lock); return -1; } } + WriteUnlock(&volume.lock); return 0; } int Ext2Init(uint8_t drive) { + WriteLock(&volume.lock, MLFQGetCurrentProcess()->pid); if (ext2_initialized) { + WriteUnlock(&volume.lock); return 0; } + volume.lock = (rwlock_t){0}; + volume.drive = drive; // The superblock is 1024 bytes long and located at offset 1024. @@ -72,6 +87,7 @@ int Ext2Init(uint8_t drive) { uint8_t sb_buffer[1024]; if (IdeReadSector(drive, 2, sb_buffer) != IDE_OK || IdeReadSector(drive, 3, sb_buffer + 512) != IDE_OK) { PrintKernelF("[EXT2] Failed to read superblock.\n"); + WriteUnlock(&volume.lock); return -1; } @@ -80,6 +96,7 @@ int Ext2Init(uint8_t drive) { // Check for EXT2 magic number if (volume.superblock.s_magic != EXT2_MAGIC) { PrintKernelF("[EXT2] Invalid magic number. Not an EXT2 filesystem.\n"); + WriteUnlock(&volume.lock); return -1; } @@ -87,6 +104,7 @@ int Ext2Init(uint8_t drive) { if (volume.superblock.s_log_block_size > 10) { // Max 1MB blocks PrintKernelF("[EXT2] Invalid block size shift: %u\n", volume.superblock.s_log_block_size); + WriteUnlock(&volume.lock); return -1; } volume.block_size = 1024 << volume.superblock.s_log_block_size; @@ -95,6 +113,7 @@ int Ext2Init(uint8_t drive) { volume.inodes_per_group = volume.superblock.s_inodes_per_group; if (volume.blocks_per_group == 0) { PrintKernelF("[EXT2] Invalid blocks_per_group: 0\n"); + WriteUnlock(&volume.lock); return -1; } volume.num_groups = (volume.superblock.s_blocks_count + volume.blocks_per_group - 1) / volume.blocks_per_group; @@ -108,6 +127,7 @@ int Ext2Init(uint8_t drive) { volume.group_descs = KernelMemoryAlloc(bgdt_size); if (!volume.group_descs) { PrintKernelF("[EXT2] Failed to allocate memory for BGD table.\n"); + WriteUnlock(&volume.lock); return -1; } @@ -115,19 +135,28 @@ int Ext2Init(uint8_t drive) { if (Ext2ReadBlock(bgdt_block, volume.group_descs) != 0) { PrintKernelF("[EXT2] Failed to read BGD table.\n"); KernelFree(volume.group_descs); + WriteUnlock(&volume.lock); return -1; } PrintKernelSuccess("[EXT2] Filesystem initialized successfully.\n"); ext2_initialized = 1; + WriteUnlock(&volume.lock); return 0; } int Ext2ReadInode(uint32_t inode_num, Ext2Inode* inode) { - if (inode_num == 0) return -1; + ReadLock(&volume.lock, MLFQGetCurrentProcess()->pid); + if (inode_num == 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return -1; + } uint32_t group = (inode_num - 1) / volume.inodes_per_group; - if (group >= volume.num_groups) return -1; + if (group >= volume.num_groups) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return -1; + } uint32_t index = (inode_num - 1) % volume.inodes_per_group; uint32_t inode_table_block = volume.group_descs[group].bg_inode_table; @@ -136,24 +165,36 @@ int Ext2ReadInode(uint32_t inode_num, Ext2Inode* inode) { uint32_t offset_in_block = (index * volume.inode_size) % volume.block_size; uint8_t* block_buffer = KernelMemoryAlloc(volume.block_size); - if (!block_buffer) return -1; + if (!block_buffer) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return -1; + } if (Ext2ReadBlock(inode_table_block + block_offset, block_buffer) != 0) { KernelFree(block_buffer); + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return -1; } FastMemcpy(inode, block_buffer + offset_in_block, sizeof(Ext2Inode)); KernelFree(block_buffer); + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return 0; } static int Ext2WriteInode(uint32_t inode_num, Ext2Inode* inode) { - if (inode_num == 0) return -1; + WriteLock(&volume.lock, MLFQGetCurrentProcess()->pid); + if (inode_num == 0) { + WriteUnlock(&volume.lock); + return -1; + } uint32_t group = (inode_num - 1) / volume.inodes_per_group; - if (group >= volume.num_groups) return -1; + if (group >= volume.num_groups) { + WriteUnlock(&volume.lock); + return -1; + } uint32_t index = (inode_num - 1) % volume.inodes_per_group; uint32_t inode_table_block = volume.group_descs[group].bg_inode_table; @@ -162,11 +203,15 @@ static int Ext2WriteInode(uint32_t inode_num, Ext2Inode* inode) { uint32_t offset_in_block = (index * volume.inode_size) % volume.block_size; uint8_t* block_buffer = KernelMemoryAlloc(volume.block_size); - if (!block_buffer) return -1; + if (!block_buffer) { + WriteUnlock(&volume.lock); + return -1; + } // Read-modify-write the block containing the inode if (Ext2ReadBlock(inode_table_block + block_offset, block_buffer) != 0) { KernelFree(block_buffer); + WriteUnlock(&volume.lock); return -1; } @@ -174,21 +219,28 @@ static int Ext2WriteInode(uint32_t inode_num, Ext2Inode* inode) { if (Ext2WriteBlock(inode_table_block + block_offset, block_buffer) != 0) { KernelFree(block_buffer); + WriteUnlock(&volume.lock); return -1; } KernelFree(block_buffer); + WriteUnlock(&volume.lock); return 0; } // Find a directory entry in a directory inode uint32_t Ext2FindInDir(Ext2Inode* dir_inode, const char* name) { + ReadLock(&volume.lock, MLFQGetCurrentProcess()->pid); if (!S_ISDIR(dir_inode->i_mode)) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return 0; // Not a directory } uint8_t* block_buffer = KernelMemoryAlloc(volume.block_size); - if (!block_buffer) return 0; + if (!block_buffer) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return 0; + } for (int i = 0; i < 12; i++) { // Only direct blocks if (dir_inode->i_block[i] == 0) continue; @@ -204,6 +256,7 @@ uint32_t Ext2FindInDir(Ext2Inode* dir_inode, const char* name) { if (FastMemcmp(entry->name, name, entry->name_len) == 0) { uint32_t inode_num = entry->inode; KernelFree(block_buffer); + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return inode_num; } } @@ -213,15 +266,19 @@ uint32_t Ext2FindInDir(Ext2Inode* dir_inode, const char* name) { } KernelFree(block_buffer); + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return 0; // Not found } uint32_t Ext2PathToInode(const char* path) { + ReadLock(&volume.lock, MLFQGetCurrentProcess()->pid); if (!ext2_initialized || !path) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return 0; } if (path[0] == '/' && (path[1] == '\0' || path[1] == ' ')) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return 2; // Root directory inode } @@ -229,6 +286,7 @@ uint32_t Ext2PathToInode(const char* path) { uint32_t current_inode_num = 2; Ext2Inode current_inode; if (Ext2ReadInode(current_inode_num, ¤t_inode) != 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return 0; } @@ -245,36 +303,49 @@ uint32_t Ext2PathToInode(const char* path) { component[i] = '\0'; if (!S_ISDIR(current_inode.i_mode)) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return 0; // Not a directory, but path continues } current_inode_num = Ext2FindInDir(¤t_inode, component); if (current_inode_num == 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return 0; // Component not found } if (Ext2ReadInode(current_inode_num, ¤t_inode) != 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return 0; // Failed to read next inode } if (*p == '/') p++; } + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return current_inode_num; } int Ext2ReadFile(const char* path, void* buffer, uint32_t max_size) { - if (!ext2_initialized) return -1; + ReadLock(&volume.lock, MLFQGetCurrentProcess()->pid); + if (!ext2_initialized) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return -1; + } uint32_t inode_num = Ext2PathToInode(path); - if (inode_num == 0) return -1; // Not found + if (inode_num == 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return -1; // Not found + } Ext2Inode inode; if (Ext2ReadInode(inode_num, &inode) != 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return -1; // Failed to read inode } if (!S_ISREG(inode.i_mode)) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return -1; // Not a regular file } @@ -283,7 +354,10 @@ int Ext2ReadFile(const char* path, void* buffer, uint32_t max_size) { uint32_t bytes_read = 0; uint8_t* block_buffer = KernelMemoryAlloc(volume.block_size); - if (!block_buffer) return -1; + if (!block_buffer) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return -1; + } // Only handle direct blocks for now for (int i = 0; i < 12 && bytes_read < bytes_to_read; i++) { @@ -291,6 +365,7 @@ int Ext2ReadFile(const char* path, void* buffer, uint32_t max_size) { if (Ext2ReadBlock(inode.i_block[i], block_buffer) != 0) { KernelFree(block_buffer); + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return -1; } @@ -303,11 +378,16 @@ int Ext2ReadFile(const char* path, void* buffer, uint32_t max_size) { } KernelFree(block_buffer); + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return bytes_read; } int Ext2WriteFile(const char* path, const void* buffer, uint32_t size) { - if (!ext2_initialized) return -1; + WriteLock(&volume.lock, MLFQGetCurrentProcess()->pid); + if (!ext2_initialized) { + WriteUnlock(&volume.lock); + return -1; + } uint32_t inode_num = Ext2PathToInode(path); @@ -315,25 +395,36 @@ int Ext2WriteFile(const char* path, const void* buffer, uint32_t size) { if (inode_num == 0) { if (Ext2CreateFile(path) != 0) { PrintKernelF("[EXT2] WriteFile: Failed to create file: %s\n", path); + WriteUnlock(&volume.lock); return -1; } inode_num = Ext2PathToInode(path); if (inode_num == 0) { PrintKernelF("[EXT2] WriteFile: Failed to find created file: %s\n", path); + WriteUnlock(&volume.lock); return -1; } } Ext2Inode inode; - if (Ext2ReadInode(inode_num, &inode) != 0) return -1; + if (Ext2ReadInode(inode_num, &inode) != 0) { + WriteUnlock(&volume.lock); + return -1; + } - if (!S_ISREG(inode.i_mode)) return -1; + if (!S_ISREG(inode.i_mode)) { + WriteUnlock(&volume.lock); + return -1; + } int bytes_written = 0; // Changed from uint32_t to int const uint8_t* data_buffer = (const uint8_t*)buffer; uint8_t* block_buffer = KernelMemoryAlloc(volume.block_size); - if (!block_buffer) return -1; + if (!block_buffer) { + WriteUnlock(&volume.lock); + return -1; + } // Write to direct blocks, overwriting existing data for (int i = 0; i < 12; i++) { @@ -373,30 +464,51 @@ int Ext2WriteFile(const char* path, const void* buffer, uint32_t size) { if ((uint32_t)bytes_written != inode.i_size) { inode.i_size = bytes_written; if (Ext2WriteInode(inode_num, &inode) != 0) { + WriteUnlock(&volume.lock); return -1; } } } - if (bytes_written <= 0 && size > 0) return -1; + if (bytes_written <= 0 && size > 0) { + WriteUnlock(&volume.lock); + return -1; + } + WriteUnlock(&volume.lock); return bytes_written; } int Ext2ListDir(const char* path) { - if (!ext2_initialized) return -1; + ReadLock(&volume.lock, MLFQGetCurrentProcess()->pid); + if (!ext2_initialized) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return -1; + } uint32_t inode_num = Ext2PathToInode(path); - if (inode_num == 0) return -1; + if (inode_num == 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return -1; + } Ext2Inode inode; - if (Ext2ReadInode(inode_num, &inode) != 0) return -1; + if (Ext2ReadInode(inode_num, &inode) != 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return -1; + } - if (!S_ISDIR(inode.i_mode)) return -1; + if (!S_ISDIR(inode.i_mode)) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return -1; + } uint8_t* block_buffer = KernelMemoryAlloc(volume.block_size); - if (!block_buffer) return -1; + if (!block_buffer) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return -1; + } PrintKernelF("Listing directory: %s\n", path); @@ -421,9 +533,11 @@ int Ext2ListDir(const char* path) { } KernelFree(block_buffer); + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); return 0; } + static int Ext2FindFreeBit(uint8_t* bitmap, uint32_t size_in_bits) { for (uint32_t i = 0; i < size_in_bits; i++) { uint32_t byte_idx = i / 8; @@ -448,8 +562,12 @@ static void Ext2ClearBit(uint8_t* bitmap, uint32_t bit) { } static uint32_t Ext2AllocateInode() { + WriteLock(&volume.lock, MLFQGetCurrentProcess()->pid); uint8_t* bitmap_buffer = KernelMemoryAlloc(volume.block_size); - if (!bitmap_buffer) return 0; + if (!bitmap_buffer) { + WriteUnlock(&volume.lock); + return 0; + } for (uint32_t group = 0; group < volume.num_groups; group++) { uint32_t inode_bitmap_block = volume.group_descs[group].bg_inode_bitmap; @@ -469,18 +587,24 @@ static uint32_t Ext2AllocateInode() { volume.superblock.s_free_inodes_count--; KernelFree(bitmap_buffer); + WriteUnlock(&volume.lock); return group * volume.inodes_per_group + free_bit + 1; } } } KernelFree(bitmap_buffer); + WriteUnlock(&volume.lock); return 0; } static uint32_t Ext2AllocateBlock() { + WriteLock(&volume.lock, MLFQGetCurrentProcess()->pid); uint8_t* bitmap_buffer = KernelMemoryAlloc(volume.block_size); - if (!bitmap_buffer) return 0; + if (!bitmap_buffer) { + WriteUnlock(&volume.lock); + return 0; + } for (uint32_t group = 0; group < volume.num_groups; group++) { uint32_t block_bitmap_block = volume.group_descs[group].bg_block_bitmap; @@ -500,23 +624,35 @@ static uint32_t Ext2AllocateBlock() { volume.superblock.s_free_blocks_count--; KernelFree(bitmap_buffer); + WriteUnlock(&volume.lock); return group * volume.blocks_per_group + free_bit + volume.superblock.s_first_data_block; } } } KernelFree(bitmap_buffer); + WriteUnlock(&volume.lock); return 0; } static int Ext2AddDirEntry(uint32_t dir_inode_num, const char* name, uint32_t file_inode_num, uint8_t file_type) { + WriteLock(&volume.lock, MLFQGetCurrentProcess()->pid); Ext2Inode dir_inode; - if (Ext2ReadInode(dir_inode_num, &dir_inode) != 0) return -1; + if (Ext2ReadInode(dir_inode_num, &dir_inode) != 0) { + WriteUnlock(&volume.lock); + return -1; + } - if (!S_ISDIR(dir_inode.i_mode)) return -1; + if (!S_ISDIR(dir_inode.i_mode)) { + WriteUnlock(&volume.lock); + return -1; + } uint8_t* block_buffer = KernelMemoryAlloc(volume.block_size); - if (!block_buffer) return -1; + if (!block_buffer) { + WriteUnlock(&volume.lock); + return -1; + } uint16_t name_len = FastStrlen(name, 255); uint16_t required_len = 8 + name_len; @@ -557,6 +693,7 @@ static int Ext2AddDirEntry(uint32_t dir_inode_num, const char* name, uint32_t fi if (Ext2WriteBlock(dir_inode.i_block[i], block_buffer) == 0) { KernelFree(block_buffer); + WriteUnlock(&volume.lock); return 0; } } @@ -583,6 +720,7 @@ static int Ext2AddDirEntry(uint32_t dir_inode_num, const char* name, uint32_t fi if (Ext2WriteBlock(new_block, block_buffer) == 0 && Ext2WriteInode(dir_inode_num, &dir_inode) == 0) { KernelFree(block_buffer); + WriteUnlock(&volume.lock); return 0; } break; @@ -590,11 +728,16 @@ static int Ext2AddDirEntry(uint32_t dir_inode_num, const char* name, uint32_t fi } KernelFree(block_buffer); + WriteUnlock(&volume.lock); return -1; } int Ext2CreateFile(const char* path) { - if (!ext2_initialized) return -1; + WriteLock(&volume.lock, MLFQGetCurrentProcess()->pid); + if (!ext2_initialized) { + WriteUnlock(&volume.lock); + return -1; + } // Extract directory path and filename char dir_path[256] = "/"; @@ -607,7 +750,10 @@ int Ext2CreateFile(const char* path) { if (last_slash && last_slash != path) { int dir_len = last_slash - path; - if (dir_len >= 255) return -1; + if (dir_len >= 255) { + WriteUnlock(&volume.lock); + return -1; + } FastMemcpy(dir_path, path, dir_len); dir_path[dir_len] = '\0'; FastStrCopy(filename, last_slash + 1, 255); @@ -617,6 +763,7 @@ int Ext2CreateFile(const char* path) { // Check if file already exists if (Ext2PathToInode(path) != 0) { + WriteUnlock(&volume.lock); return 0; // Success - file exists } @@ -624,6 +771,7 @@ int Ext2CreateFile(const char* path) { uint32_t parent_inode_num = Ext2PathToInode(dir_path); if (parent_inode_num == 0) { PrintKernelF("[EXT2] CreateFile: Parent directory not found: %s\n", dir_path); + WriteUnlock(&volume.lock); return -1; } @@ -631,6 +779,7 @@ int Ext2CreateFile(const char* path) { uint32_t new_inode_num = Ext2AllocateInode(); if (new_inode_num == 0) { PrintKernelF("[EXT2] CreateFile: Failed to allocate inode\n"); + WriteUnlock(&volume.lock); return -1; } @@ -638,6 +787,7 @@ int Ext2CreateFile(const char* path) { uint32_t first_block = Ext2AllocateBlock(); if (first_block == 0) { PrintKernelF("[EXT2] CreateFile: Failed to allocate data block\n"); + WriteUnlock(&volume.lock); return -1; } @@ -658,12 +808,14 @@ int Ext2CreateFile(const char* path) { // Write inode if (Ext2WriteInode(new_inode_num, &new_inode) != 0) { PrintKernelF("[EXT2] CreateFile: Failed to write inode\n"); + WriteUnlock(&volume.lock); return -1; } // Add directory entry if (Ext2AddDirEntry(parent_inode_num, filename, new_inode_num, 1) != 0) { // 1 = regular file PrintKernelF("[EXT2] CreateFile: Failed to add directory entry\n"); + WriteUnlock(&volume.lock); return -1; } @@ -676,12 +828,18 @@ int Ext2CreateFile(const char* path) { } PrintKernelSuccessF("[EXT2] Created file: %s (inode %u)\n", path, new_inode_num); + WriteUnlock(&volume.lock); return 0; } + int Ext2CreateDir(const char* path) { - if (!ext2_initialized) return -1; + WriteLock(&volume.lock, MLFQGetCurrentProcess()->pid); + if (!ext2_initialized) { + WriteUnlock(&volume.lock); + return -1; + } // Extract directory path and dirname char parent_path[256] = "/"; @@ -694,7 +852,10 @@ int Ext2CreateDir(const char* path) { if (last_slash && last_slash != path) { int parent_len = last_slash - path; - if (parent_len >= 255) return -1; + if (parent_len >= 255) { + WriteUnlock(&volume.lock); + return -1; + } FastMemcpy(parent_path, path, parent_len); parent_path[parent_len] = '\0'; FastStrCopy(dirname, last_slash + 1, 255); @@ -704,6 +865,7 @@ int Ext2CreateDir(const char* path) { // Check if directory already exists if (Ext2PathToInode(path) != 0) { + WriteUnlock(&volume.lock); return 0; } @@ -711,6 +873,7 @@ int Ext2CreateDir(const char* path) { uint32_t parent_inode_num = Ext2PathToInode(parent_path); if (parent_inode_num == 0) { PrintKernelF("[EXT2] CreateDir: Parent directory not found: %s\n", parent_path); + WriteUnlock(&volume.lock); return -1; } @@ -718,6 +881,7 @@ int Ext2CreateDir(const char* path) { uint32_t new_inode_num = Ext2AllocateInode(); if (new_inode_num == 0) { PrintKernelF("[EXT2] CreateDir: Failed to allocate inode\n"); + WriteUnlock(&volume.lock); return -1; } @@ -725,6 +889,7 @@ int Ext2CreateDir(const char* path) { uint32_t dir_block = Ext2AllocateBlock(); if (dir_block == 0) { PrintKernelF("[EXT2] CreateDir: Failed to allocate data block\n"); + WriteUnlock(&volume.lock); return -1; } @@ -744,7 +909,10 @@ int Ext2CreateDir(const char* path) { // Create directory entries (. and ..) uint8_t* dir_buffer = KernelMemoryAlloc(volume.block_size); - if (!dir_buffer) return -1; + if (!dir_buffer) { + WriteUnlock(&volume.lock); + return -1; + } FastMemset(dir_buffer, 0, volume.block_size); @@ -770,6 +938,7 @@ int Ext2CreateDir(const char* path) { Ext2WriteInode(new_inode_num, &new_inode) != 0) { KernelFree(dir_buffer); PrintKernelF("[EXT2] CreateDir: Failed to write directory data\n"); + WriteUnlock(&volume.lock); return -1; } @@ -778,6 +947,7 @@ int Ext2CreateDir(const char* path) { // Add directory entry to parent if (Ext2AddDirEntry(parent_inode_num, dirname, new_inode_num, 2) != 0) { // 2 = directory PrintKernelF("[EXT2] CreateDir: Failed to add directory entry\n"); + WriteUnlock(&volume.lock); return -1; } @@ -789,61 +959,225 @@ int Ext2CreateDir(const char* path) { } PrintKernelSuccessF("[EXT2] Created directory: %s (inode %u)\n", path, new_inode_num); + WriteUnlock(&volume.lock); return 0; } + +static void Ext2FreeBlock(uint32_t block_num) { + if (block_num == 0) return; + + uint32_t group = (block_num - volume.superblock.s_first_data_block) / volume.blocks_per_group; + uint32_t bit = (block_num - volume.superblock.s_first_data_block) % volume.blocks_per_group; + + uint8_t* bitmap_buffer = KernelMemoryAlloc(volume.block_size); + if (!bitmap_buffer) return; + + uint32_t bitmap_block = volume.group_descs[group].bg_block_bitmap; + if (Ext2ReadBlock(bitmap_block, bitmap_buffer) == 0) { + Ext2ClearBit(bitmap_buffer, bit); + if (Ext2WriteBlock(bitmap_block, bitmap_buffer) == 0) { + volume.group_descs[group].bg_free_blocks_count++; + volume.superblock.s_free_blocks_count++; + } + } + + KernelFree(bitmap_buffer); +} + +static void Ext2FreeInode(uint32_t inode_num) { + if (inode_num < 2) return; + + uint32_t group = (inode_num - 1) / volume.inodes_per_group; + uint32_t bit = (inode_num - 1) % volume.inodes_per_group; + + uint8_t* bitmap_buffer = KernelMemoryAlloc(volume.block_size); + if (!bitmap_buffer) return; + + uint32_t bitmap_block = volume.group_descs[group].bg_inode_bitmap; + if (Ext2ReadBlock(bitmap_block, bitmap_buffer) == 0) { + Ext2ClearBit(bitmap_buffer, bit); + if (Ext2WriteBlock(bitmap_block, bitmap_buffer) == 0) { + volume.group_descs[group].bg_free_inodes_count++; + volume.superblock.s_free_inodes_count++; + } + } + + KernelFree(bitmap_buffer); +} + + int Ext2Delete(const char* path) { - if (!ext2_initialized) return -1; + WriteLock(&volume.lock, MLFQGetCurrentProcess()->pid); + if (!ext2_initialized) { + WriteUnlock(&volume.lock); + return -1; + } uint32_t inode_num = Ext2PathToInode(path); if (inode_num == 0) { PrintKernelF("[EXT2] Delete: File not found: %s\n", path); - return -1; + WriteUnlock(&volume.lock); + return -1; // Not found } Ext2Inode inode; - if (Ext2ReadInode(inode_num, &inode) != 0) return -1; + if (Ext2ReadInode(inode_num, &inode) != 0) { + WriteUnlock(&volume.lock); + return -1; + } - // For now, only implement file deletion (not directories) - if (!S_ISREG(inode.i_mode)) { - PrintKernelF("[EXT2] Delete: Directory deletion not yet implemented: %s\n", path); + // Free all data blocks + for (int i = 0; i < 12; i++) { + if (inode.i_block[i] != 0) { + Ext2FreeBlock(inode.i_block[i]); + inode.i_block[i] = 0; + } + } + // TODO: Handle indirect blocks + + // Mark inode as deleted + inode.i_dtime = 0; // TODO: Get current time + inode.i_links_count = 0; + if (Ext2WriteInode(inode_num, &inode) != 0) { + WriteUnlock(&volume.lock); return -1; } - // TODO: Complete implementation - remove directory entry, free inode and data blocks - PrintKernelF("[EXT2] Delete: %s (Implementation in progress)\n", path); - return -1; + Ext2FreeInode(inode_num); + + // Remove directory entry + char dir_path[256] = "/"; + const char* last_slash = NULL; + for (const char* p = path; *p; p++) { + if (*p == '/') last_slash = p; + } + + if (last_slash && last_slash != path) { + int dir_len = last_slash - path; + if (dir_len < 256) { + FastMemcpy(dir_path, path, dir_len); + dir_path[dir_len] = '\0'; + } + } + + uint32_t parent_inode_num = Ext2PathToInode(dir_path); + if (parent_inode_num == 0) { + WriteUnlock(&volume.lock); + return -1; // Should not happen + } + + Ext2Inode parent_inode; + if (Ext2ReadInode(parent_inode_num, &parent_inode) != 0) { + WriteUnlock(&volume.lock); + return -1; + } + + uint8_t* block_buffer = KernelMemoryAlloc(volume.block_size); + if (!block_buffer) { + WriteUnlock(&volume.lock); + return -1; + } + + int res = -1; + for (int i = 0; i < 12; i++) { + if (parent_inode.i_block[i] == 0) continue; + if (Ext2ReadBlock(parent_inode.i_block[i], block_buffer) != 0) continue; + + Ext2DirEntry* entry = (Ext2DirEntry*)block_buffer; + Ext2DirEntry* prev_entry = NULL; + uint32_t offset = 0; + + while (offset < volume.block_size && entry->rec_len > 0) { + if (entry->inode == inode_num) { + if (prev_entry) { + prev_entry->rec_len += entry->rec_len; + } else { + entry->inode = 0; // First entry in block + } + if (Ext2WriteBlock(parent_inode.i_block[i], block_buffer) == 0) { + res = 0; + } + goto end_delete_loop; + } + prev_entry = entry; + offset += entry->rec_len; + entry = (Ext2DirEntry*)((uint8_t*)block_buffer + offset); + } + } + +end_delete_loop: + KernelFree(block_buffer); + WriteUnlock(&volume.lock); + return res; } + int Ext2IsFile(const char* path) { - if (!ext2_initialized) return 0; + ReadLock(&volume.lock, MLFQGetCurrentProcess()->pid); + if (!ext2_initialized) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return 0; + } uint32_t inode_num = Ext2PathToInode(path); - if (inode_num == 0) return 0; + if (inode_num == 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return 0; + } Ext2Inode inode; - if (Ext2ReadInode(inode_num, &inode) != 0) return 0; + if (Ext2ReadInode(inode_num, &inode) != 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return 0; + } - return S_ISREG(inode.i_mode); + int result = S_ISREG(inode.i_mode); + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return result; } int Ext2IsDir(const char* path) { - if (!ext2_initialized) return 0; + ReadLock(&volume.lock, MLFQGetCurrentProcess()->pid); + if (!ext2_initialized) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return 0; + } uint32_t inode_num = Ext2PathToInode(path); - if (inode_num == 0) return 0; + if (inode_num == 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return 0; + } Ext2Inode inode; - if (Ext2ReadInode(inode_num, &inode) != 0) return 0; + if (Ext2ReadInode(inode_num, &inode) != 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return 0; + } - return S_ISDIR(inode.i_mode); + int result = S_ISDIR(inode.i_mode); + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return result; } uint64_t Ext2GetFileSize(const char* path) { - if (!ext2_initialized) return 0; + ReadLock(&volume.lock, MLFQGetCurrentProcess()->pid); + if (!ext2_initialized) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return 0; + } uint32_t inode_num = Ext2PathToInode(path); - if (inode_num == 0) return 0; + if (inode_num == 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return 0; + } Ext2Inode inode; - if (Ext2ReadInode(inode_num, &inode) != 0) return 0; + if (Ext2ReadInode(inode_num, &inode) != 0) { + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return 0; + } - return inode.i_size; + uint64_t size = inode.i_size; + ReadUnlock(&volume.lock, MLFQGetCurrentProcess()->pid); + return size; } \ No newline at end of file diff --git a/kernel/atomic/Spinlock.h b/kernel/atomic/Spinlock.h index 93b20e5..6503ae3 100644 --- a/kernel/atomic/Spinlock.h +++ b/kernel/atomic/Spinlock.h @@ -90,9 +90,15 @@ static inline void MCSUnlock(volatile mcs_node_t** lock, mcs_node_t* node) { typedef struct { volatile int readers; volatile int writer; + volatile uint32_t owner; + volatile int recursion; } rwlock_t; -static inline void ReadLock(rwlock_t* lock) { +static inline void ReadLock(rwlock_t* lock, uint32_t owner_id) { + if (lock->writer && lock->owner == owner_id) { + // The current process holds the write lock, so it can "read" + return; + } while (1) { while (lock->writer) __builtin_ia32_pause(); __sync_fetch_and_add(&lock->readers, 1); @@ -101,19 +107,34 @@ static inline void ReadLock(rwlock_t* lock) { } } -static inline void ReadUnlock(rwlock_t* lock) { +static inline void ReadUnlock(rwlock_t* lock, uint32_t owner_id) { + if (lock->writer && lock->owner == owner_id) { + // This was a recursive read "lock" by the write lock owner, so do nothing + return; + } __sync_fetch_and_sub(&lock->readers, 1); } -static inline void WriteLock(rwlock_t* lock) { +static inline void WriteLock(rwlock_t* lock, uint32_t owner_id) { + if (lock->writer && lock->owner == owner_id) { + lock->recursion++; + return; + } + while (__sync_lock_test_and_set(&lock->writer, 1)) { while (lock->writer) __builtin_ia32_pause(); } while (lock->readers) __builtin_ia32_pause(); + + lock->owner = owner_id; + lock->recursion = 1; } static inline void WriteUnlock(rwlock_t* lock) { - __sync_lock_release(&lock->writer); + if (--lock->recursion == 0) { + lock->owner = 0; + __sync_lock_release(&lock->writer); + } } // Original API preserved diff --git a/kernel/sched/MLFQ.c b/kernel/sched/MLFQ.c index 226b9fc..e88aea8 100644 --- a/kernel/sched/MLFQ.c +++ b/kernel/sched/MLFQ.c @@ -1237,15 +1237,15 @@ MLFQProcessControlBlock* MLFQGetCurrentProcess(void) { } MLFQProcessControlBlock* MLFQGetCurrentProcessByPID(uint32_t pid) { - ReadLock(&process_table_rwlock); + ReadLock(&process_table_rwlock, pid); for (int i = 0; i < MAX_PROCESSES; i++) { if (processes[i].pid == pid && processes[i].state != PROC_TERMINATED) { MLFQProcessControlBlock* found = &processes[i]; - ReadUnlock(&process_table_rwlock); + ReadUnlock(&process_table_rwlock, pid); return found; } } - ReadUnlock(&process_table_rwlock); + ReadUnlock(&process_table_rwlock, pid); return NULL; } @@ -1943,7 +1943,7 @@ void MLFQDumpSchedulerState(void) { // Get detailed process scheduling information void MLFQGetProcessStats(uint32_t pid, uint32_t* cpu_time, uint32_t* io_ops, uint32_t* preemptions) { - ReadLock(&process_table_rwlock); + ReadLock(&process_table_rwlock, pid); MLFQProcessControlBlock* proc = MLFQGetCurrentProcessByPID(pid); if (!proc) { if (cpu_time) *cpu_time = 0; @@ -1955,5 +1955,5 @@ void MLFQGetProcessStats(uint32_t pid, uint32_t* cpu_time, uint32_t* io_ops, uin if (cpu_time) *cpu_time = (uint32_t)proc->cpu_time_accumulated; if (io_ops) *io_ops = proc->io_operations; if (preemptions) *preemptions = proc->preemption_count; - ReadUnlock(&process_table_rwlock); + ReadUnlock(&process_table_rwlock, pid); } \ No newline at end of file From cc682537fc06e445bde7a0118e6033a2e6b6a83f Mon Sep 17 00:00:00 2001 From: Atheria Date: Sun, 7 Sep 2025 07:31:33 +0700 Subject: [PATCH 2/4] RTC update --- drivers/RTC/Rtc.c | 214 ++++++++++++++++++++++----------------- drivers/RTC/Rtc.h | 5 +- drivers/vmware/.keep | 0 fs/VFS.c | 2 +- kernel/atomic/Spinlock.h | 8 +- kernel/sched/MLFQ.c | 7 +- 6 files changed, 136 insertions(+), 100 deletions(-) create mode 100644 drivers/vmware/.keep diff --git a/drivers/RTC/Rtc.c b/drivers/RTC/Rtc.c index 35ab92c..9844cf4 100644 --- a/drivers/RTC/Rtc.c +++ b/drivers/RTC/Rtc.c @@ -1,105 +1,131 @@ -#include "Rtc.h" +#include "RTC/Rtc.h" #include "Io.h" +#include "stdbool.h" -#define CMOS_ADDRESS 0x70 -#define CMOS_DATA 0x71 - -// CMOS Register numbers -#define CMOS_REG_SECONDS 0x00 -#define CMOS_REG_MINUTES 0x02 -#define CMOS_REG_HOURS 0x04 -#define CMOS_REG_DAY 0x07 -#define CMOS_REG_MONTH 0x08 -#define CMOS_REG_YEAR 0x09 -#define CMOS_REG_CENTURY 0x32 // Common on newer systems - -#define CMOS_REG_STATUS_A 0x0A -#define CMOS_REG_STATUS_B 0x0B - -static uint8_t cmos_read(uint8_t reg) { - // Select the register, making sure NMI is disabled - outb(CMOS_ADDRESS, (1 << 7) | reg); - // Read the data - return inb(CMOS_DATA); +#define RTC_CMOS_ADDRESS 0x70 +#define RTC_CMOS_DATA 0x71 + +#define RTC_SECONDS 0x00 +#define RTC_MINUTES 0x02 +#define RTC_HOURS 0x04 +#define RTC_DAY_OF_WEEK 0x06 +#define RTC_DAY_OF_MONTH 0x07 +#define RTC_MONTH 0x08 +#define RTC_YEAR 0x09 +#define RTC_CENTURY 0x32 // Most common century register +#define RTC_STATUS_A 0x0A +#define RTC_STATUS_B 0x0B +#define RTC_STATUS_C 0x0C + +typedef rtc_time_t RtcDateTime; + +static uint8_t Rtc_ReadRegister(uint8_t reg) { + outb(RTC_CMOS_ADDRESS, reg); + return inb(RTC_CMOS_DATA); } -static int get_update_in_progress_flag() { - return cmos_read(CMOS_REG_STATUS_A) & 0x80; +static void Rtc_WriteRegister(uint8_t reg, uint8_t value) { + outb(RTC_CMOS_ADDRESS, reg); + outb(RTC_CMOS_DATA, value); } -static uint8_t bcd_to_bin(uint8_t bcd) { - return (bcd & 0x0F) + ((bcd >> 4) * 10); +int Rtc_BcdToBinary(uint8_t bcd) { + return (bcd & 0x0F) + ((bcd / 16) * 10); } -void RtcReadTime(rtc_time_t* rtc_time) { - rtc_time_t last_time; - uint8_t status_b; - - // The robust way to read the RTC is to read it twice and see if the - // values match. This ensures an update didn't happen in the middle of our read. - do { - // Wait until no update is in progress - while (get_update_in_progress_flag()) {} - - rtc_time->second = cmos_read(CMOS_REG_SECONDS); - rtc_time->minute = cmos_read(CMOS_REG_MINUTES); - rtc_time->hour = cmos_read(CMOS_REG_HOURS); - rtc_time->day = cmos_read(CMOS_REG_DAY); - rtc_time->month = cmos_read(CMOS_REG_MONTH); - rtc_time->year = cmos_read(CMOS_REG_YEAR); - rtc_time->century = cmos_read(CMOS_REG_CENTURY); - // Make a copy of the values we just read - last_time = *rtc_time; - - // Wait again to ensure we are past the update - while (get_update_in_progress_flag()){} - - // Read a second time - last_time.second = cmos_read(CMOS_REG_SECONDS); - last_time.minute = cmos_read(CMOS_REG_MINUTES); - last_time.hour = cmos_read(CMOS_REG_HOURS); - last_time.day = cmos_read(CMOS_REG_DAY); - last_time.month = cmos_read(CMOS_REG_MONTH); - last_time.year = cmos_read(CMOS_REG_YEAR); -#ifdef VF_CONFIG_RTC_CENTURY - last_time.century = cmos_read(CMOS_REG_CENTURY); -#endif - - } while ( (last_time.second != rtc_time->second) || - (last_time.minute != rtc_time->minute) || - (last_time.hour != rtc_time->hour) || - (last_time.day != rtc_time->day) || - (last_time.month != rtc_time->month) || - (last_time.year != rtc_time->year) -#ifdef VF_CONFIG_RTC_CENTURY - || (last_time.century != rtc_time->century) -#endif - ); - - - // Now that we have a stable read, convert from BCD if necessary - status_b = cmos_read(CMOS_REG_STATUS_B); - - if (!(status_b & 0x04)) { // Bit 2 clear means BCD mode - rtc_time->second = bcd_to_bin(rtc_time->second); - rtc_time->minute = bcd_to_bin(rtc_time->minute); - // Handle 12/24 hour clock for the hour value - rtc_time->hour = ((rtc_time->hour & 0x7F) + 12 * ((rtc_time->hour & 0x80) != 0)) % 24; - rtc_time->day = bcd_to_bin(rtc_time->day); - rtc_time->month = bcd_to_bin(rtc_time->month); - rtc_time->year = bcd_to_bin(rtc_time->year); +uint8_t Rtc_BinaryToBcd(uint8_t binary) { + return ((binary / 10) << 4) | (binary % 10); +} + +static bool Rtc_IsUpdating() { + Rtc_WriteRegister(RTC_STATUS_A, 0x0A); // Select register A + return (Rtc_ReadRegister(RTC_STATUS_A) & 0x80); // Check update in progress bit +} + +void RtcReadTime(RtcDateTime *dateTime) { + uint8_t second, minute, hour, day, month, year, century; + uint8_t statusB; + + // Wait until the update in progress bit is 0 + while (Rtc_IsUpdating()); + + // Read RTC registers + second = Rtc_ReadRegister(RTC_SECONDS); + minute = Rtc_ReadRegister(RTC_MINUTES); + hour = Rtc_ReadRegister(RTC_HOURS); + day = Rtc_ReadRegister(RTC_DAY_OF_MONTH); + month = Rtc_ReadRegister(RTC_MONTH); + year = Rtc_ReadRegister(RTC_YEAR); + century = Rtc_ReadRegister(RTC_CENTURY); // Read century byte + + statusB = Rtc_ReadRegister(RTC_STATUS_B); + + if (!(statusB & 0x04)) { // If BCD mode + dateTime->second = Rtc_BcdToBinary(second); + dateTime->minute = Rtc_BcdToBinary(minute); + dateTime->hour = Rtc_BcdToBinary(hour); + dateTime->day = Rtc_BcdToBinary(day); + dateTime->month = Rtc_BcdToBinary(month); + dateTime->year = Rtc_BcdToBinary(year); + dateTime->century = Rtc_BcdToBinary(century); + } else { // Binary mode + dateTime->second = second; + dateTime->minute = minute; + dateTime->hour = hour; + dateTime->day = day; + dateTime->month = month; + dateTime->year = year; + dateTime->century = century; } -#ifdef VF_CONFIG_RTC_CENTURY - { - uint16_t cval = (uint16_t)rtc_time->century; - if (cval != 0) { - cval = bcd_to_bin((uint8_t)cval); - rtc_time->year += (uint16_t)(cval * 100); - } else { - rtc_time->year += 2000; - } + + if (!(statusB & 0x02) && (dateTime->hour & 0x80)) { // 12-hour format and PM + dateTime->hour = ((dateTime->hour & 0x7F) + 12) % 24; + } + + // Calculate full year + dateTime->year += dateTime->century * 100; +} + +void RtcSetTime(const RtcDateTime *dateTime) { + uint8_t statusB; + uint8_t second, minute, hour, day, month, year, century; + + // Read current status B to preserve settings + statusB = Rtc_ReadRegister(RTC_STATUS_B); + + // Disable NMI and updates while setting time + Rtc_WriteRegister(RTC_CMOS_ADDRESS, RTC_STATUS_B | 0x80); // Disable NMI + Rtc_WriteRegister(RTC_STATUS_B, statusB | 0x80); // Disable updates + + // Convert to BCD if necessary + if (!(statusB & 0x04)) { // If BCD mode + second = Rtc_BinaryToBcd(dateTime->second); + minute = Rtc_BinaryToBcd(dateTime->minute); + hour = Rtc_BinaryToBcd(dateTime->hour); + day = Rtc_BinaryToBcd(dateTime->day); + month = Rtc_BinaryToBcd(dateTime->month); + year = Rtc_BinaryToBcd(dateTime->year % 100); + century = Rtc_BinaryToBcd(dateTime->year / 100); + } else { // Binary mode + second = dateTime->second; + minute = dateTime->minute; + hour = dateTime->hour; + day = dateTime->day; + month = dateTime->month; + year = dateTime->year % 100; + century = dateTime->year / 100; } -#else - rtc_time->year += 2000; -#endif + + // Write to RTC registers + Rtc_WriteRegister(RTC_SECONDS, second); + Rtc_WriteRegister(RTC_MINUTES, minute); + Rtc_WriteRegister(RTC_HOURS, hour); + Rtc_WriteRegister(RTC_DAY_OF_MONTH, day); + Rtc_WriteRegister(RTC_MONTH, month); + Rtc_WriteRegister(RTC_YEAR, year); + Rtc_WriteRegister(RTC_CENTURY, century); + + // Re-enable updates and NMI + Rtc_WriteRegister(RTC_STATUS_B, statusB); + Rtc_WriteRegister(RTC_CMOS_ADDRESS, RTC_STATUS_B); // Re-enable NMI } \ No newline at end of file diff --git a/drivers/RTC/Rtc.h b/drivers/RTC/Rtc.h index 374aab2..8977ae8 100644 --- a/drivers/RTC/Rtc.h +++ b/drivers/RTC/Rtc.h @@ -1,7 +1,7 @@ #ifndef VOIDFRAME_RTC_H #define VOIDFRAME_RTC_H -#include +#include "stdint.h" // A structure to hold the date and time. typedef struct { @@ -16,5 +16,8 @@ typedef struct { // Reads the current date and time from the RTC into the provided struct. void RtcReadTime(rtc_time_t* rtc_time); +void RtcSetTime(const rtc_time_t *dateTime); +uint8_t Rtc_BinaryToBcd(uint8_t binary); +int Rtc_BcdToBinary(uint8_t bcd); #endif // VOIDFRAME_RTC_H diff --git a/drivers/vmware/.keep b/drivers/vmware/.keep new file mode 100644 index 0000000..e69de29 diff --git a/fs/VFS.c b/fs/VFS.c index 3872978..77d7622 100644 --- a/fs/VFS.c +++ b/fs/VFS.c @@ -82,7 +82,7 @@ int VfsInit(void) { if (disk_result == 0) { SerialWriteF("[VFS] FAT12 mounted at %s/VFSystemDrive\n", DevicesStorage); } else { - SerialWrite("[VFS] FAT12 mount failed\n"); + SerialWrite("[VFS] FAT12 mount failed\n");'' } } else { PrintKernel("[VFS] Skipping FAT12 mount - Not initialized\n"); diff --git a/kernel/atomic/Spinlock.h b/kernel/atomic/Spinlock.h index 6503ae3..89cb7f3 100644 --- a/kernel/atomic/Spinlock.h +++ b/kernel/atomic/Spinlock.h @@ -94,6 +94,8 @@ typedef struct { volatile int recursion; } rwlock_t; +#define RWLOCK_INIT { .readers = 0, .writer = 0, .owner = 0, .recursion = 0 } + static inline void ReadLock(rwlock_t* lock, uint32_t owner_id) { if (lock->writer && lock->owner == owner_id) { // The current process holds the write lock, so it can "read" @@ -109,7 +111,7 @@ static inline void ReadLock(rwlock_t* lock, uint32_t owner_id) { static inline void ReadUnlock(rwlock_t* lock, uint32_t owner_id) { if (lock->writer && lock->owner == owner_id) { - // This was a recursive read "lock" by the write lock owner, so do nothing + __atomic_thread_fence(__ATOMIC_RELEASE); return; } __sync_fetch_and_sub(&lock->readers, 1); @@ -131,6 +133,10 @@ static inline void WriteLock(rwlock_t* lock, uint32_t owner_id) { } static inline void WriteUnlock(rwlock_t* lock) { + if (lock->recursion <= 0) { + // This is a serious error - unlock without lock + return; // Or trigger an assertion/panic in debug builds + } if (--lock->recursion == 0) { lock->owner = 0; __sync_lock_release(&lock->writer); diff --git a/kernel/sched/MLFQ.c b/kernel/sched/MLFQ.c index e88aea8..c190bf8 100644 --- a/kernel/sched/MLFQ.c +++ b/kernel/sched/MLFQ.c @@ -1237,15 +1237,16 @@ MLFQProcessControlBlock* MLFQGetCurrentProcess(void) { } MLFQProcessControlBlock* MLFQGetCurrentProcessByPID(uint32_t pid) { - ReadLock(&process_table_rwlock, pid); + MLFQProcessControlBlock* current = MLFQGetCurrentProcess(); + ReadLock(&process_table_rwlock, current->pid); for (int i = 0; i < MAX_PROCESSES; i++) { if (processes[i].pid == pid && processes[i].state != PROC_TERMINATED) { MLFQProcessControlBlock* found = &processes[i]; - ReadUnlock(&process_table_rwlock, pid); + ReadUnlock(&process_table_rwlock, current->pid); return found; } } - ReadUnlock(&process_table_rwlock, pid); + ReadUnlock(&process_table_rwlock, current->pid); return NULL; } From c9c55dc27c006f4af4d08aa318b5a6d8d0bb334a Mon Sep 17 00:00:00 2001 From: Atheria Date: Sun, 7 Sep 2025 07:48:41 +0700 Subject: [PATCH 3/4] VMware SVGA II --- drivers/vmware/.keep | 0 drivers/vmware/SVGAII.c | 163 ++++++++++++++ drivers/vmware/SVGAII.h | 468 ++++++++++++++++++++++++++++++++++++++++ fs/VFS.c | 2 +- kernel/core/Kernel.c | 16 +- meson.build | 3 + 6 files changed, 649 insertions(+), 3 deletions(-) delete mode 100644 drivers/vmware/.keep create mode 100644 drivers/vmware/SVGAII.c create mode 100644 drivers/vmware/SVGAII.h diff --git a/drivers/vmware/.keep b/drivers/vmware/.keep deleted file mode 100644 index e69de29..0000000 diff --git a/drivers/vmware/SVGAII.c b/drivers/vmware/SVGAII.c new file mode 100644 index 0000000..a303b58 --- /dev/null +++ b/drivers/vmware/SVGAII.c @@ -0,0 +1,163 @@ +#include "SVGAII.h" +#include "../../drivers/PCI/PCI.h" // Assuming PCI.h is in the parent directory +#include "../../include/Io.h" // Assuming Io.h is in include/ +#include "../../mm/VMem.h" // Assuming VMem.h is in mm/ + +// Global device info instance +SVGAII_DeviceInfo svgaII_device; + +// Helper functions for SVGA II register access +static inline void SVGAII_WriteReg(uint16_t index, uint32_t value) { + outl(svgaII_device.io_port_base + SVGA_INDEX, index); + outl(svgaII_device.io_port_base + SVGA_VALUE, value); +} + +static inline uint32_t SVGAII_ReadReg(uint16_t index) { + outl(svgaII_device.io_port_base + SVGA_INDEX, index); + return inl(svgaII_device.io_port_base + SVGA_VALUE); +} + +// Function to detect and initialize the SVGA II device +bool SVGAII_DetectAndInitialize() { + PciDevice pci_dev; + + // 1. Detect SVGA II PCI device + if (!PciFindDevice(SVGAII_PCI_VENDOR_ID, SVGAII_PCI_DEVICE_ID, &pci_dev)) { + // Device not found + svgaII_device.initialized = false; + return false; + } + + // Store PCI info (bus, device, function) if needed later + // pci_dev.bus, pci_dev.device, pci_dev.function + + // 2. Get I/O port base from BAR0 + // The OSDev Wiki states: "The base I/O port (SVGA_PORT_BASE) is not fixed and is derived by subtracting 1 from BAR0 in the PCI configuration." + uint32_t bar0 = PciConfigReadDWord(pci_dev.bus, pci_dev.device, pci_dev.function, PCI_BAR0_REG); + svgaII_device.io_port_base = (uint16_t)(bar0 & 0xFFFC) - 1; // Clear lower bits and subtract 1 + + // Enable memory space and bus mastering for the device + uint16_t command_reg = PciConfigReadDWord(pci_dev.bus, pci_dev.device, pci_dev.function, PCI_COMMAND_REG); + command_reg |= (PCI_CMD_MEM_SPACE_EN | PCI_CMD_BUS_MASTER_EN); + PciConfigWriteDWord(pci_dev.bus, pci_dev.device, pci_dev.function, PCI_COMMAND_REG, command_reg); + + // 3. Negotiate SVGA ID + SVGAII_WriteReg(SVGA_REG_ID, SVGA_ID_2); // Try ID_2 first, as it's common + if (SVGAII_ReadReg(SVGA_REG_ID) != SVGA_ID_2) { + SVGAII_WriteReg(SVGA_REG_ID, SVGA_ID_0); // Fallback to ID_0 + if (SVGAII_ReadReg(SVGA_REG_ID) != SVGA_ID_0) { + // Could not negotiate a supported ID + svgaII_device.initialized = false; + return false; + } + } + + // 4. Get Framebuffer and FIFO addresses and sizes + uint32_t fb_phys_addr = SVGAII_ReadReg(SVGA_REG_FB_START); + uint32_t fb_size = SVGAII_ReadReg(SVGA_REG_FB_SIZE); + uint32_t fifo_phys_addr = SVGAII_ReadReg(SVGA_REG_FIFO_START); + uint32_t fifo_size = SVGAII_ReadReg(SVGA_REG_FIFO_SIZE); + + // 5. Map Framebuffer and FIFO into virtual memory + // Framebuffer mapping + svgaII_device.framebuffer = (uint32_t*)VMemMapMMIO(0, fb_phys_addr, fb_size, VMEM_WRITE | VMEM_NOCACHE); + if (svgaII_device.framebuffer == NULL) { + svgaII_device.initialized = false; + return false; + } + svgaII_device.fb_size = fb_size; + + // FIFO mapping + svgaII_device.fifo_ptr = (uint32_t*)VMemMapMMIO(0, fifo_phys_addr, fifo_size, VMEM_WRITE | VMEM_NOCACHE); + if (svgaII_device.fifo_ptr == NULL) { + // Unmap framebuffer if FIFO mapping fails + VMemUnmapMMIO((uint64_t)svgaII_device.framebuffer, svgaII_device.fb_size); + svgaII_device.initialized = false; + return false; + } + svgaII_device.fifo_size = fifo_size; + + // Initialize FIFO (as per OSDev Wiki, write 0 to FIFO_MIN and FIFO_MAX) + // This part needs more specific FIFO initialization details from OSDev Wiki or other sources. + // For now, a basic setup: + svgaII_device.fifo_ptr[0] = 0; // FIFO_MIN + svgaII_device.fifo_ptr[1] = fifo_size; // FIFO_MAX + svgaII_device.fifo_ptr[2] = 0; // FIFO_NEXT_CMD + svgaII_device.fifo_ptr[3] = 0; // FIFO_STOP + + // 6. Enable SVGA mode + SVGAII_WriteReg(SVGA_REG_ENABLE, 1); + + svgaII_device.initialized = true; + return true; +} + +// Function to set display mode +void SVGAII_SetMode(uint32_t width, uint32_t height, uint32_t bpp) { + if (!svgaII_device.initialized) return; + + SVGAII_WriteReg(SVGA_REG_WIDTH, width); + SVGAII_WriteReg(SVGA_REG_HEIGHT, height); + SVGAII_WriteReg(SVGA_REG_BPP, bpp); + + // Update device info + svgaII_device.width = width; + svgaII_device.height = height; + svgaII_device.bpp = bpp; + svgaII_device.pitch = width * (bpp / 8); // Assuming linear framebuffer + + // Trigger mode set (usually by writing to SVGA_REG_ENABLE again or a specific command) + // OSDev Wiki suggests writing 1 to SVGA_REG_ENABLE after setting mode registers. + SVGAII_WriteReg(SVGA_REG_ENABLE, 1); + + // Update the screen to reflect the new mode + SVGAII_UpdateScreen(0, 0, width, height); +} + +// Function to put a pixel (direct framebuffer access) +void SVGAII_PutPixel(uint32_t x, uint32_t y, uint32_t color) { + if (!svgaII_device.initialized || x >= svgaII_device.width || y >= svgaII_device.height) return; + + // Assuming 32-bit BPP for simplicity (color is ARGB) + // Need to handle different BPP values (16, 24) if required. + if (svgaII_device.bpp == 32) { + svgaII_device.framebuffer[(y * svgaII_device.width) + x] = color; + } + // Add logic for 16-bit, 24-bit if necessary +} + +// Function to update a portion of the screen using FIFO command +void SVGAII_UpdateScreen(uint32_t x, uint32_t y, uint32_t width, uint32_t height) { + if (!svgaII_device.initialized) return; + + // Ensure FIFO is ready for commands + // This is a simplified FIFO write. A proper FIFO implementation needs to handle + // FIFO head/tail, wrap-around, and waiting for space. + // For now, assume enough space and direct write. + uint32_t* fifo = svgaII_device.fifo_ptr; + uint32_t next_cmd_offset = fifo[2]; // FIFO_NEXT_CMD + + fifo[next_cmd_offset / 4] = SVGA_CMD_UPDATE; + fifo[(next_cmd_offset + 4) / 4] = x; + fifo[(next_cmd_offset + 8) / 4] = y; + fifo[(next_cmd_offset + 12) / 4] = width; + fifo[(next_cmd_offset + 16) / 4] = height; + + fifo[2] = (next_cmd_offset + 20) % svgaII_device.fifo_size; // Update FIFO_NEXT_CMD + + // Tell the device there are new commands + outl(svgaII_device.io_port_base + SVGA_BIOS, 0); // Write anything to SVGA_BIOS to kick the FIFO +} + +// Function to fill a rectangle (direct framebuffer access and then update) +void SVGAII_FillRect(uint32_t x, uint32_t y, uint32_t width, uint32_t height, uint32_t color) { + if (!svgaII_device.initialized) return; + + // Simple fill by iterating pixels. Can be optimized with memset/memcpy for larger areas. + for (uint32_t j = y; j < y + height; ++j) { + for (uint32_t i = x; i < x + width; ++i) { + SVGAII_PutPixel(i, j, color); + } + } + SVGAII_UpdateScreen(x, y, width, height); +} diff --git a/drivers/vmware/SVGAII.h b/drivers/vmware/SVGAII.h new file mode 100644 index 0000000..957821b --- /dev/null +++ b/drivers/vmware/SVGAII.h @@ -0,0 +1,468 @@ +#ifndef SVGAII_H +#define SVGAII_H + +#include +#include + +// PCI IDs for VMware SVGA II +#define SVGAII_PCI_VENDOR_ID 0x15AD +#define SVGAII_PCI_DEVICE_ID 0x0405 + +// SVGA II Register Offsets (relative to SVGA_PORT_BASE) +#define SVGA_INDEX 0x00 +#define SVGA_VALUE 0x01 +#define SVGA_BIOS 0x02 +#define SVGA_IRQSTATUS 0x08 + +// SVGA II Register IDs (used with SVGA_INDEX/SVGA_VALUE) +#define SVGA_REG_ID 0 +#define SVGA_REG_ENABLE 1 +#define SVGA_REG_WIDTH 2 +#define SVGA_REG_HEIGHT 3 +#define SVGA_REG_MAX_WIDTH 4 +#define SVGA_REG_MAX_HEIGHT 5 +#define SVGA_REG_DEPTH 6 +#define SVGA_REG_BPP 7 // bits per pixel +#define SVGA_REG_FB_START 13 +#define SVGA_REG_FB_SIZE 14 +#define SVGA_REG_FIFO_START 18 +#define SVGA_REG_FIFO_SIZE 19 +#define SVGA_REG_CAPABILITIES 20 +#define SVGA_REG_MEM_SIZE 21 +#define SVGA_REG_GUEST_ID 22 +#define SVGA_REG_CURSOR_ID 23 +#define SVGA_REG_CURSOR_X 24 +#define SVGA_REG_CURSOR_Y 25 +#define SVGA_REG_CURSOR_ON 26 +#define SVGA_REG_HOST_BITS_PER_PIXEL 27 +#define SVGA_REG_ALPHA_CURSOR_ID 28 +#define SVGA_REG_ALPHA_CURSOR_FRAME 29 +#define SVGA_REG_ALPHA_CURSOR_WIDTH 30 +#define SVGA_REG_ALPHA_CURSOR_HEIGHT 31 +#define SVGA_REG_ALPHA_CURSOR_HOTSPOT_X 32 +#define SVGA_REG_ALPHA_CURSOR_HOTSPOT_Y 33 +#define SVGA_REG_ALPHA_CURSOR_DATA 34 +#define SVGA_REG_ALPHA_CURSOR_DATA_SIZE 35 +#define SVGA_REG_FENCE 36 +#define SVGA_REG_FENCE_PASSTHRU 37 +#define SVGA_REG_NUM_DISPLAYS 38 +#define SVGA_REG_PITCHLOCK 39 +#define SVGA_REG_IRQMASK 40 +#define SVGA_REG_NUM_GUEST_DISPLAYS 41 +#define SVGA_REG_DISPLAY_ID 42 +#define SVGA_REG_DISPLAY_WIDTH 43 +#define SVGA_REG_DISPLAY_HEIGHT 44 +#define SVGA_REG_DISPLAY_POSITION_X 45 +#define SVGA_REG_DISPLAY_POSITION_Y 46 +#define SVGA_REG_DISPLAY_IS_PRIMARY 47 +#define SVGA_REG_DISPLAY_MODE_ID 48 +#define SVGA_REG_DISPLAY_CONTENT_ID 49 +#define SVGA_REG_DISPLAY_CLONE_ID 50 +#define SVGA_REG_DISPLAY_CLONE_MODE_ID 51 +#define SVGA_REG_DISPLAY_CLONE_CONTENT_ID 52 +#define SVGA_REG_DISPLAY_CLONE_POSITION_X 53 +#define SVGA_REG_DISPLAY_CLONE_POSITION_Y 54 +#define SVGA_REG_DISPLAY_CLONE_IS_PRIMARY 55 +#define SVGA_REG_DISPLAY_CLONE_NUM_DISPLAYS 56 +#define SVGA_REG_DISPLAY_CLONE_NUM_GUEST_DISPLAYS 57 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_ID 58 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_WIDTH 59 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_HEIGHT 60 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_POSITION_X 61 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_POSITION_Y 62 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_IS_PRIMARY 63 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_MODE_ID 64 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CONTENT_ID 65 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_ID 66 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_MODE_ID 67 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_CONTENT_ID 68 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_X 69 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_Y 70 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_IS_PRIMARY 71 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_NUM_DISPLAYS 72 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_NUM_GUEST_DISPLAYS 73 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_ID 74 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_WIDTH 75 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_HEIGHT 76 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_X 77 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_Y 78 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_IS_PRIMARY 79 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_MODE_ID 80 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CONTENT_ID 81 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_ID 82 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_MODE_ID 83 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_CONTENT_ID 84 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_X 85 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_Y 86 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_IS_PRIMARY 87 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_DISPLAYS 88 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_GUEST_DISPLAYS 89 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_ID 90 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_WIDTH 91 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_HEIGHT 92 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_X 93 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_Y 94 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_IS_PRIMARY 95 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_MODE_ID 96 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CONTENT_ID 97 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_ID 98 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_MODE_ID 99 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_CONTENT_ID 100 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_X 101 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_Y 102 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_IS_PRIMARY 103 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_DISPLAYS 104 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_GUEST_DISPLAYS 105 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_ID 106 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_WIDTH 107 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_HEIGHT 108 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_X 109 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_Y 110 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_IS_PRIMARY 111 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_MODE_ID 112 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CONTENT_ID 113 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_ID 114 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_MODE_ID 115 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_CONTENT_ID 116 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_X 117 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_Y 118 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_IS_PRIMARY 119 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_DISPLAYS 120 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_GUEST_DISPLAYS 121 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_ID 122 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_WIDTH 123 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_HEIGHT 124 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_X 125 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_Y 126 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_IS_PRIMARY 127 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_MODE_ID 128 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CONTENT_ID 129 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_ID 130 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_MODE_ID 131 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_CONTENT_ID 132 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_X 133 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_Y 134 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_IS_PRIMARY 135 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_DISPLAYS 136 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_GUEST_DISPLAYS 137 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_ID 138 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_WIDTH 139 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_HEIGHT 140 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_X 141 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_Y 142 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_IS_PRIMARY 143 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_MODE_ID 144 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CONTENT_ID 145 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_ID 146 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_MODE_ID 147 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_CONTENT_ID 148 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_X 149 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_Y 150 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_IS_PRIMARY 151 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_DISPLAYS 152 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_GUEST_DISPLAYS 153 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_ID 154 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_WIDTH 155 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_HEIGHT 156 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_X 157 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_Y 158 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_IS_PRIMARY 159 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_MODE_ID 160 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CONTENT_ID 161 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_ID 162 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_MODE_ID 163 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_CONTENT_ID 164 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_X 165 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_Y 166 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_IS_PRIMARY 167 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_DISPLAYS 168 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_GUEST_DISPLAYS 169 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_ID 170 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_WIDTH 171 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_HEIGHT 172 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_X 173 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_Y 174 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_IS_PRIMARY 175 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_MODE_ID 176 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CONTENT_ID 177 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_ID 178 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_MODE_ID 179 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_CONTENT_ID 180 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_X 181 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_Y 182 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_IS_PRIMARY 183 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_DISPLAYS 184 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_NUM_GUEST_DISPLAYS 185 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_ID 186 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_WIDTH 187 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_HEIGHT 188 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_X 189 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_POSITION_Y 190 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_IS_PRIMARY 191 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_MODE_ID 192 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CONTENT_ID 193 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_ID 194 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_MODE_ID 195 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_CONTENT_ID 196 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_X 197 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_POSITION_Y 198 +#define SVGA_REG_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_DISPLAY_CLONE_IS_PRIMARY 199 + +// SVGA II FIFO Commands +#define SVGA_CMD_UPDATE 1 +#define SVGA_CMD_RECT_COPY 3 +#define SVGA_CMD_DEFINE_CURSOR 10 +#define SVGA_CMD_DEFINE_ALPHA_CURSOR 11 +#define SVGA_CMD_SET_CURSOR_STATE 12 +#define SVGA_CMD_SET_CURSOR_POSITION 13 +#define SVGA_CMD_SET_MODE 16 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN 17 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE 18 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE 19 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_ALPHA 20 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_ALPHA 21 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_ALPHA 22 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_ALPHA_AND_COLOR_KEY 23 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_ALPHA_AND_COLOR_KEY 24 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_ALPHA_AND_COLOR_KEY 25 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY 26 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY 27 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY 28 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA 29 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA 30 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA 31 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 32 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 33 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 34 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 35 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 36 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 37 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 38 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 39 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 40 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 41 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 42 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 43 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 44 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 45 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 46 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 47 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 48 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 49 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 50 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 51 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 52 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 53 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 54 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 55 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 56 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 57 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 58 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 59 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 60 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 61 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 62 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 63 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 64 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 65 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 66 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 67 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 68 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 69 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 70 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 71 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 72 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 73 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 74 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 75 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 76 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 77 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 78 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 79 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 80 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 81 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 82 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 83 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 84 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 85 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 86 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 87 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 88 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 89 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 90 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 91 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 92 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 93 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 94 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 95 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 96 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 97 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 98 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 99 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 100 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 101 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 102 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 103 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 104 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 105 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 106 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 107 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 108 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 109 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 110 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 111 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 112 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 113 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 114 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 115 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 116 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 117 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 118 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 119 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 120 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 121 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 122 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 123 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 124 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 125 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 126 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 127 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 128 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 129 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 130 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 131 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 132 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 133 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 134 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 135 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 136 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 137 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 138 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 139 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 140 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 141 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 142 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 143 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 144 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 145 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 146 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 147 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 148 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 149 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 150 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 151 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 152 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 153 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 154 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 155 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 156 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 157 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 158 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 159 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 160 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 161 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 162 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 163 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 164 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 165 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 166 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 167 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 168 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 169 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 170 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 171 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 172 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 173 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 174 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 175 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 176 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 177 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 178 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 179 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 180 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 181 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 182 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 183 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 184 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 185 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 186 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 187 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 188 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 189 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 190 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 191 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 192 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 193 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA 194 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 195 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 196 +#define SVGA_CMD_BLIT_SURFACE_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 197 +#define SVGA_CMD_BLIT_SCREEN_TO_SURFACE_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 198 +#define SVGA_CMD_BLIT_SURFACE_TO_SCREEN_WITH_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY_AND_ALPHA_AND_COLOR_KEY 199 + +// SVGA II Capabilities +#define SVGA_CAP_NONE 0x00000000 +#define SVGA_CAP_RECT_FILL 0x00000001 +#define SVGA_CAP_RECT_COPY 0x00000002 +#define SVGA_CAP_RECT_PAT_FILL 0x00000004 +#define SVGA_CAP_ALPHA_CURSOR 0x00000008 +#define SVGA_CAP_VIDEO_OVERLAY 0x00000010 +#define SVGA_CAP_VIDEO_CAPTURE 0x00000020 +#define SVGA_CAP_PRESENT 0x00000040 +#define SVGA_CAP_TRUNCATE_FENCE 0x00000080 +#define SVGA_CAP_FENCE_PASSTHRU 0x00000100 +#define SVGA_CAP_IRQ_MASK 0x00000200 +#define SVGA_CAP_DISPLAY_TOPOLOGY 0x00000400 +#define SVGA_CAP_PITCHLOCK 0x00000800 +#define SVGA_CAP_IRQSAVE 0x00001000 +#define SVGA_CAP_CMD_BUFFER 0x00002000 +#define SVGA_CAP_CMD_BUFFER_2 0x00004000 +#define SVGA_CAP_CMD_BUFFER_3 0x00008000 +#define SVGA_CAP_CMD_BUFFER_4 0x00010000 +#define SVGA_CAP_CMD_BUFFER_5 0x00020000 +#define SVGA_CAP_CMD_BUFFER_6 0x00040000 +#define SVGA_CAP_CMD_BUFFER_7 0x00080000 +#define SVGA_CAP_CMD_BUFFER_8 0x00100000 +#define SVGA_CAP_CMD_BUFFER_9 0x00200000 +#define SVGA_CAP_CMD_BUFFER_10 0x00400000 +#define SVGA_CAP_CMD_BUFFER_11 0x00800000 +#define SVGA_CAP_CMD_BUFFER_12 0x01000000 +#define SVGA_CAP_CMD_BUFFER_13 0x02000000 +#define SVGA_CAP_CMD_BUFFER_14 0x04000000 +#define SVGA_CAP_CMD_BUFFER_15 0x08000000 +#define SVGA_CAP_CMD_BUFFER_16 0x10000000 +#define SVGA_CAP_CMD_BUFFER_17 0x20000000 +#define SVGA_CAP_CMD_BUFFER_18 0x40000000 +#define SVGA_CAP_CMD_BUFFER_19 0x80000000 + +// SVGA II ID values +#define SVGA_ID_0 0x90000000 +#define SVGA_ID_1 0x90000001 +#define SVGA_ID_2 0x90000002 +#define SVGA_ID_3 0x90000003 +#define SVGA_ID_CURRENT SVGA_ID_3 + +// Global SVGA II device information +typedef struct { + uint16_t io_port_base; + uint32_t* framebuffer; + uint32_t fb_size; + uint32_t* fifo_ptr; + uint32_t fifo_size; + uint32_t width; + uint32_t height; + uint32_t bpp; + uint32_t pitch; + bool initialized; +} SVGAII_DeviceInfo; + +extern SVGAII_DeviceInfo svgaII_device; + +// Function Prototypes +bool SVGAII_DetectAndInitialize(); +void SVGAII_SetMode(uint32_t width, uint32_t height, uint32_t bpp); +void SVGAII_PutPixel(uint32_t x, uint32_t y, uint32_t color); +void SVGAII_UpdateScreen(uint32_t x, uint32_t y, uint32_t width, uint32_t height); +void SVGAII_FillRect(uint32_t x, uint32_t y, uint32_t width, uint32_t height, uint32_t color); + +#endif // SVGAII_H diff --git a/fs/VFS.c b/fs/VFS.c index 77d7622..3872978 100644 --- a/fs/VFS.c +++ b/fs/VFS.c @@ -82,7 +82,7 @@ int VfsInit(void) { if (disk_result == 0) { SerialWriteF("[VFS] FAT12 mounted at %s/VFSystemDrive\n", DevicesStorage); } else { - SerialWrite("[VFS] FAT12 mount failed\n");'' + SerialWrite("[VFS] FAT12 mount failed\n"); } } else { PrintKernel("[VFS] Skipping FAT12 mount - Not initialized\n"); diff --git a/kernel/core/Kernel.c b/kernel/core/Kernel.c index e2ab87a..51c1f65 100644 --- a/kernel/core/Kernel.c +++ b/kernel/core/Kernel.c @@ -29,6 +29,7 @@ #include "VFS.h" #include "VMem.h" #include "Vesa.h" +#include "SVGAII.h" #include "ethernet/RTL8139.h" #include "stdbool.h" #include "stdint.h" @@ -42,6 +43,7 @@ extern uint8_t _kernel_phys_end[]; // Global variable to store the Multiboot2 info address static uint32_t g_multiboot_info_addr = 0; +bool g_svgaII_active = false; void ParseMultibootInfo(uint32_t info) { g_multiboot_info_addr = info; @@ -430,7 +432,9 @@ void PXS1(const uint32_t info) { } if (VBEInit(info) != 0) { - PrintKernelError("System: Failed to initialize VBE and graphical environment"); + PrintKernelError("System: Failed to initialize VBE and graphical environment\n"); + } else { + PrintKernelSuccess("System: VBE driver initialized\n"); } PrintKernel("System: Starting Console...\n"); @@ -624,6 +628,7 @@ static InitResultT PXS2(void) { PitInstall(); PrintKernelSuccess("System: PIC & PIT initialized\n"); + #ifdef VF_CONFIG_ENABLE_PS2 // Initialize keyboard PrintKernel("Info: Initializing keyboard...\n"); @@ -712,6 +717,13 @@ static InitResultT PXS2(void) { PrintKernelSuccess("System: RTL8139 Driver initialized\n"); #endif +#ifdef VF_CONFIG_ENABLE_VMWARE_SVGA_II + if (SVGAII_DetectAndInitialize()) { + g_svgaII_active = true; + PrintKernelSuccess("System: VMware SVGA II driver initialized\n"); + } +#endif + #ifdef VF_CONFIG_ENABLE_XHCI PrintKernel("Info: Initializing xHCI...\n"); xHCIInit(); @@ -779,7 +791,7 @@ void KernelMainHigherHalf(void) { sti(); while (1) { - if (VBEIsInitialized()) { + if (g_svgaII_active || VBEIsInitialized()) { WindowManagerRun(); MLFQYield(); } else { diff --git a/meson.build b/meson.build index bad92e0..3a3895c 100644 --- a/meson.build +++ b/meson.build @@ -67,6 +67,7 @@ inc_dirs = [ src_root + '/drivers/ISA', src_root + '/drivers/sound', src_root + '/drivers/virtio', + src_root + '/drivers/vmware', src_root + '/fs', src_root + '/fs/FAT', src_root + '/fs/EXT', @@ -131,6 +132,7 @@ c_sources = [ src_root + '/drivers/APIC.c', src_root + '/drivers/InterruptController.c', src_root + '/drivers/virtio/VirtioBlk.c', + src_root + '/drivers/vmware/SVGAII.c', src_root + '/include/ctype.c', src_root + '/include/Font.c', arch_root + '/idt/Idt.c', @@ -153,6 +155,7 @@ vf_config_flags = [ '-DVF_CONFIG_ENABLE_PS2', '-DVF_CONFIG_ENABLE_IDE', '-DVF_CONFIG_ENABLE_VFCOMPOSITOR', +# '-DVF_CONFIG_ENABLE_VMWARE_SVGA_II', '-DVF_CONFIG_RTC_CENTURY', '-DVF_CONFIG_ENFORCE_MEMORY_PROTECTION', '-DVF_CONFIG_VM_HOST', From 06c4c8bd75920ace68cb8166b47d4a97a5e38793 Mon Sep 17 00:00:00 2001 From: Atheria Date: Sun, 7 Sep 2025 08:29:15 +0700 Subject: [PATCH 4/4] Docs & fixes --- README.md | 110 ++++++++++++++++++++++++++++++++--- docs/ARCHITECTURE.md | 2 +- drivers/RTC/Rtc.c | 4 +- drivers/vmware/SVGAII.c | 44 ++++++++------ kernel/atomic/Spinlock.h | 2 +- kernel/core/Kernel.c | 2 +- kernel/etc/Shell.c | 4 +- kernel/etc/objects/panic.o | Bin 1920592 -> 1920592 bytes kernel/etc/objects/splash1.o | Bin 1920600 -> 1920600 bytes meson.build | 2 +- 10 files changed, 138 insertions(+), 32 deletions(-) diff --git a/README.md b/README.md index fe6bb59..7866fb1 100644 --- a/README.md +++ b/README.md @@ -14,15 +14,13 @@ ![License](https://img.shields.io/badge/License-GPLv2-orange) -![Version](https://img.shields.io/badge/Current%20Version-v0.0.1%20beta6-blue) +![Version](https://img.shields.io/badge/Current%20Version-v0.0.1%20beta6.1-blue) -![Build](https://img.shields.io/badge/GCC-faliling-red) - -![Build](https://img.shields.io/badge/Clang-passing-brightgreen) +![Build](https://img.shields.io/badge/Build-passing-brightgreen) ## About -VoidFrame is a 64-bit syscall-less **monolithic** kernel designed for the x86_64 architecture written in C and assembly (nasm). +VoidFrame is a 64-bit syscall-less **monolithic** kernel (sounds weird and contradicting right?) designed for the x86_64 architecture written in C and assembly (nasm). This kernel was intended and targeted for people who want to learn about operating systems and want to make a piece of their own. As the designer of this kernel, I wanted to make something that is simple, fast, secure and easy to understand. Which obviously means that it is not a perfect kernel. And it breaks all the time. @@ -36,7 +34,7 @@ It would be amazing if you could contribute to this project! - ninja >= 1.11 - clang >= 18.0.0 (or any C-compliant compiler) - nasm >= 2.16 -- qemu >= 7.0.0 +- qemu >= 7.0.0 (minimum, failed to run on Limbo emulator (v5.x)) - mkfs.fat (dosfstools) - mkfs.ext2 - grub-mkrescue @@ -63,4 +61,102 @@ meson setup build -Dexclude_extra_objects=true cd build ninja ninja runmin -``` \ No newline at end of file +``` + +## Features +### Architecture +- [x] x86_64 +- [ ] AArch64 +- [ ] MIPS +- [ ] SPARC +- [ ] RISC-V (RV64) +- [ ] Power (modern) +### Boot +- [x] Multiboot2 +- [x] GRUB (BIOS) +- [ ] GRUB (UEFI) +- [ ] GRUB (Hybrid) +- [x] Vesa (VBE) +- [x] Multiboot2 Info parsing +### Core +- [x] Multi-tasking (MLFQ) +- [x] Per-process authentication check (Astra) +- [x] Dynamic ML-inspired PIT frequency scaling (DynamoX) +- [x] Virtual Memory (canonical) +- [x] Physical Memory +- [x] Memory Pool +- [x] AVX2/SSE2 accelerated memory operations +- [x] Memory & user protection +- [x] Memory canaries, guard pages +- [x] Per-process memory checks (Cerberus) +- [x] Stack guard +- [x] Stack trace +- [x] Heap (Class-based) +- [x] Paging +- [x] Interrupts +- [x] Process Management +- [x] Locks (MCS/RW/norm) +- [x] Atomics +- [x] IPC +- [x] Compositor +- [x] Embedded shell +- [x] Builtin Editor +- [x] ELF64 loader +- [ ] PE32+/COFF loader +- [ ] a.out loader +### Filesystems +- FAT1x + - [x] Read + - [x] Write + - [x] Create + - [x] Delete + - [x] List +- EXT2 + - [x] Read + - [x] Write + - [x] Create + - [x] Delete + - [x] List +- VFRFS (VoidFrame RAMFS) + - [x] Read + - [x] Write + - [x] Create + - [x] Delete + - [x] List +- ISO9660 (RO) + - [x] Read + - [x] List +- VFS (Virtual File System) + - [x] Full abstraction + - [x] EXT2 + - [x] FAT1x + - [x] VFRFS + - [ ] ISO9660 +### Drivers +- Network + - [x] RTL8139 (PCI) +- Sound + - [x] SB16 (PCI) +- USB + - [x] xHCI +- VirtIO + - [x] Block +- Graphics + - [x] Vesa (VBE) + - [x] VMWare SVGA II + - [x] VGA text mode +- Timer + - [x] PIT + - [x] PIC + - [x] APIC (not working) + - [x] RTC +- Generic + - [x] PCI + - [x] ISA + - [x] xHCI + - [x] Serial + - [x] PS/2 + - [x] LPT +- Storage + - [x] PATA (IDE) + - [x] VirtIO Block \ No newline at end of file diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 25ac524..4516a57 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -1,4 +1,4 @@ -# The VoidFrame monolithic kernel 💫 v0.0.1-beta6 +# The VoidFrame monolithic kernel 💫 v0.0.1-beta6.1 ## Table of Contents diff --git a/drivers/RTC/Rtc.c b/drivers/RTC/Rtc.c index 9844cf4..e0ebd2b 100644 --- a/drivers/RTC/Rtc.c +++ b/drivers/RTC/Rtc.c @@ -38,8 +38,8 @@ uint8_t Rtc_BinaryToBcd(uint8_t binary) { } static bool Rtc_IsUpdating() { - Rtc_WriteRegister(RTC_STATUS_A, 0x0A); // Select register A - return (Rtc_ReadRegister(RTC_STATUS_A) & 0x80); // Check update in progress bit + outb(RTC_CMOS_ADDRESS, 0x80 | RTC_STATUS_A); // select reg A, NMI masked + return (inb(RTC_CMOS_DATA) & 0x80) != 0; // UIP bit } void RtcReadTime(RtcDateTime *dateTime) { diff --git a/drivers/vmware/SVGAII.c b/drivers/vmware/SVGAII.c index a303b58..18f350c 100644 --- a/drivers/vmware/SVGAII.c +++ b/drivers/vmware/SVGAII.c @@ -34,12 +34,16 @@ bool SVGAII_DetectAndInitialize() { // 2. Get I/O port base from BAR0 // The OSDev Wiki states: "The base I/O port (SVGA_PORT_BASE) is not fixed and is derived by subtracting 1 from BAR0 in the PCI configuration." uint32_t bar0 = PciConfigReadDWord(pci_dev.bus, pci_dev.device, pci_dev.function, PCI_BAR0_REG); - svgaII_device.io_port_base = (uint16_t)(bar0 & 0xFFFC) - 1; // Clear lower bits and subtract 1 + // I/O BAR: bit0=1 => I/O space; mask off low two bits per PCI spec + if ((bar0 & 1) == 0) { + // TODO: handle MMIO BAR0 + } else { + svgaII_device.io_port_base = (uint16_t)(bar0 & ~0x3u); + } - // Enable memory space and bus mastering for the device - uint16_t command_reg = PciConfigReadDWord(pci_dev.bus, pci_dev.device, pci_dev.function, PCI_COMMAND_REG); - command_reg |= (PCI_CMD_MEM_SPACE_EN | PCI_CMD_BUS_MASTER_EN); - PciConfigWriteDWord(pci_dev.bus, pci_dev.device, pci_dev.function, PCI_COMMAND_REG, command_reg); + uint32_t cmdsts = PciConfigReadDWord(pci_dev.bus, pci_dev.device, pci_dev.function, PCI_COMMAND_REG); + cmdsts |= (uint32_t)(PCI_CMD_MEM_SPACE_EN | PCI_CMD_BUS_MASTER_EN); + PciConfigWriteDWord(pci_dev.bus, pci_dev.device, pci_dev.function, PCI_COMMAND_REG, cmdsts); // 3. Negotiate SVGA ID SVGAII_WriteReg(SVGA_REG_ID, SVGA_ID_2); // Try ID_2 first, as it's common @@ -58,24 +62,28 @@ bool SVGAII_DetectAndInitialize() { uint32_t fifo_phys_addr = SVGAII_ReadReg(SVGA_REG_FIFO_START); uint32_t fifo_size = SVGAII_ReadReg(SVGA_REG_FIFO_SIZE); - // 5. Map Framebuffer and FIFO into virtual memory - // Framebuffer mapping - svgaII_device.framebuffer = (uint32_t*)VMemMapMMIO(0, fb_phys_addr, fb_size, VMEM_WRITE | VMEM_NOCACHE); - if (svgaII_device.framebuffer == NULL) { + uint64_t fb_phys_aligned = fb_phys_addr & ~0xFFFULL; + uint64_t fb_off = fb_phys_addr - fb_phys_aligned; + uint64_t fb_size_aligned = (fb_off + fb_size + 0xFFFULL) & ~0xFFFULL; + uint64_t fb_virt = (uint64_t)PHYS_TO_VIRT(fb_phys_aligned); + if (VMemMapMMIO(fb_virt, fb_phys_aligned, fb_size_aligned, VMEM_WRITE | VMEM_NOCACHE) != VMEM_SUCCESS) { svgaII_device.initialized = false; return false; } - svgaII_device.fb_size = fb_size; + svgaII_device.framebuffer = (uint32_t*)(fb_virt + fb_off); + svgaII_device.fb_size = (uint32_t)fb_size_aligned; // FIFO mapping - svgaII_device.fifo_ptr = (uint32_t*)VMemMapMMIO(0, fifo_phys_addr, fifo_size, VMEM_WRITE | VMEM_NOCACHE); - if (svgaII_device.fifo_ptr == NULL) { - // Unmap framebuffer if FIFO mapping fails - VMemUnmapMMIO((uint64_t)svgaII_device.framebuffer, svgaII_device.fb_size); + uint64_t fifo_phys_aligned = fifo_phys_addr & ~0xFFFULL; + uint64_t fifo_off = fifo_phys_addr - fifo_phys_aligned; + uint64_t fifo_size_aligned = (fifo_off + fifo_size + 0xFFFULL) & ~0xFFFULL; + uint64_t fifo_virt = (uint64_t)PHYS_TO_VIRT(fifo_phys_aligned); + if (VMemMapMMIO(fifo_virt, fifo_phys_aligned, fifo_size_aligned, VMEM_WRITE | VMEM_NOCACHE) != VMEM_SUCCESS) { svgaII_device.initialized = false; return false; } - svgaII_device.fifo_size = fifo_size; + svgaII_device.fifo_ptr = (uint32_t*)(fifo_virt + fifo_off); + svgaII_device.fifo_size = (uint32_t)fifo_size_aligned; // Initialize FIFO (as per OSDev Wiki, write 0 to FIFO_MIN and FIFO_MAX) // This part needs more specific FIFO initialization details from OSDev Wiki or other sources. @@ -86,7 +94,7 @@ bool SVGAII_DetectAndInitialize() { svgaII_device.fifo_ptr[3] = 0; // FIFO_STOP // 6. Enable SVGA mode - SVGAII_WriteReg(SVGA_REG_ENABLE, 1); + SVGAII_SetMode(800, 600, 32); svgaII_device.initialized = true; return true; @@ -121,7 +129,9 @@ void SVGAII_PutPixel(uint32_t x, uint32_t y, uint32_t color) { // Assuming 32-bit BPP for simplicity (color is ARGB) // Need to handle different BPP values (16, 24) if required. if (svgaII_device.bpp == 32) { - svgaII_device.framebuffer[(y * svgaII_device.width) + x] = color; + uint32_t* fb32 = svgaII_device.framebuffer; + uint32_t stride_pixels = svgaII_device.pitch / 4; + fb32[y * stride_pixels + x] = color; } // Add logic for 16-bit, 24-bit if necessary } diff --git a/kernel/atomic/Spinlock.h b/kernel/atomic/Spinlock.h index 89cb7f3..1ca6ac6 100644 --- a/kernel/atomic/Spinlock.h +++ b/kernel/atomic/Spinlock.h @@ -134,7 +134,7 @@ static inline void WriteLock(rwlock_t* lock, uint32_t owner_id) { static inline void WriteUnlock(rwlock_t* lock) { if (lock->recursion <= 0) { - // This is a serious error - unlock without lock + PANIC("WriteUnlock Underflow"); return; // Or trigger an assertion/panic in debug builds } if (--lock->recursion == 0) { diff --git a/kernel/core/Kernel.c b/kernel/core/Kernel.c index 51c1f65..b7cc744 100644 --- a/kernel/core/Kernel.c +++ b/kernel/core/Kernel.c @@ -764,7 +764,7 @@ asmlinkage void KernelMain(const uint32_t magic, const uint32_t info) { console.buffer = (volatile uint16_t*)VGA_BUFFER_ADDR; ClearScreen(); - PrintKernelSuccess("System: VoidFrame Kernel - Version 0.0.1-beta6 loaded\n"); + PrintKernelSuccess("System: VoidFrame Kernel - Version 0.0.1-beta6.1 loaded\n"); PrintKernel("Magic: "); PrintKernelHex(magic); PrintKernel(", Info: "); diff --git a/kernel/etc/Shell.c b/kernel/etc/Shell.c index f814316..bb40eb9 100644 --- a/kernel/etc/Shell.c +++ b/kernel/etc/Shell.c @@ -144,9 +144,9 @@ static void ARPTestHandler(const char * args) { static void VersionHandler(const char * args) { (void)args; - PrintKernelSuccess("VoidFrame v0.0.1-beta6\n"); + PrintKernelSuccess("VoidFrame v0.0.1-beta6.1\n"); PrintKernelF("Built on %s at %s\n", DATE, TIME); - PrintKernelSuccess("VoidFrame Shell v0.0.1-beta\n"); + PrintKernelSuccess("VoidFrame Shell v0.0.1-beta6.1\n"); } static void HelpHandler(const char * args) { diff --git a/kernel/etc/objects/panic.o b/kernel/etc/objects/panic.o index 0cbc226b74a4f1caaaf30dba4fea3fe8181a5081..45ced3722b03bdc9c4e4f75a89dff657525f1754 100644 GIT binary patch delta 1787 zcma)7TT5eC6#g`+NqS;ZokWcutMP&;)gAaq3-!S;*gD|f>Yu9roBMjq$9rj*lt+m(s*0)#Qd*8kH zzH_k<7RoeC%f4Y@Ovm)hz`kVyGqP}IVrKRoi(rxL4YM#Si(=6%hS^vwi~Co+aC<8B zg27-wPEHQ2R;#Dj7JQV3PfS)_W@aYrcDtw8s!2&nk$y}vH%l{bOjw z{kFBWg`}h;^-P;D*hqhQ#q{5wlR3yO|1#z^i4-XHa)oK+x?CtF#IXM}N zi;Jp`HVq98=o2TSs4Zg2bJTiY!qWcl!Q>GJZVv9xI?#`2^o zc|x2PwY0XjmYW_N90a@YJ%M608nL~-4M7k%J;-ipX$j5E%@`ja$IQ&k3qL8$Cw}j* zkb%(a^}M5Gu(q}a;xHvj`(UA1l#3#-u~BRlAn5rKz_ilS)BgwJCE~;adNik}r2w{LPJB9Jg~gH%vqx<@C-zU z;2a$t<$z63PphAaO+;f70{ZCa2vJc{{H(UGYLmL2ooNGE%jrq#`0Bl;S0gPqh0h zYXiUj9RC#ZA1XM7(f|Me delta 1763 zcmZ8i*)ObF5HI?pUCr0%Zn|eaxg_>MJct=$NryzNx07p$WbhzDGKj4ugxF4kSZ-Sn zL56FBwoNx;h<$q^6aRo$nYVf1ZRTOVs<~gM@2%wYsdK(_>eR35SJh8T)~6+FAM;?I zOvMD|#k`rC`LK7)muZ+E^JgN{vH%vyf|!o!nSlkf5N2d1_8t5FP`dl12@4B@#Kc7K z^z@uG8@R1V6x0a`2@oD0&OiMv8u*S)3RAVVwoaNWbU{Hu5Fa1!8o|NAlV+1ztJQ*D zuXmb9G-Tk%#l=OKo124yfdM!@J%x~v5O5crP6x-w$1pfJ2(z=Zu)4a64)FKOQUcf8 zCF7(;QkR#PgKT-y9Ior?>Vk!Z1?cYXrjeDEh0Z>`N`l(qaDd5Va++H-Jn1)4_~8DK z`~eV6Sy>sN5k-=dlVN#zSy|GI4yUE1x%S%H+MuecivMbt5~|P6&OoElKt)9bR99C6 zB5;?SoE)gDtAp6sSlUiaO@-UrTd-QKP*6}ndx9W9Zf-8r*49E&Qj+WX^z<~>W{8n$ zgeYHhnys3T=#63wPugrYh>nhim6a91oVm;0-JSaquCK4ZT4NNpwzddK9U|G>+=Tr6 zd?+j|g!}t@h=_=w3-j~y(A3lf>FMbd?~;-ddd%r`LQzo>#KpzYx#s3(ib7^)ChY9& zKz4RE?eFgHk}h+E|6U}Tw2h68P+wn9ALU0dNgojfqC*J?2!M@^4bu1b_rcH4k96hd z=H^CGX}-L?{A%sxRXh0mWq6Z&6}kz-?HG%&9ySbOdv_3`lm3^O{0 zc^@7gc8&i2e!BB5dSo!BtFNyQrlzJ~W@d(8zDkB4+`Yljyu7@COl5Lle0&_9pPxw& z3=DLd8#U!f5)2hOpa`PJ2B1iBaWRaHjL=eU2sEQ(rKP3H5tx{mfV{jsxV3aQ| zE@+7k;*hywB*GwRqN1VzNr$@p7&5-#;o$))D=QTnG-G!`!XX#1rhR>VY5(!@ks1v? zjBRv#dz;RE>0bQ(Uvi6dI7Fehv$GS{*4Dsow*%*#D2ygBrbkCd)Ksw`Gcq#BGRFVv z>WUbNVQ6V-p&rN>gQ1}zf{XQt&3JEb57yV$DRfAA>>vtkG6ujG_1bqTqV(kdZC@o9 z5&!2^3RPn@VLz7_8Qk)Q{aoNby-9lR;G&@Q@bLIz1VGk#Z;fc;NqH1l0Y00T=>Px# diff --git a/kernel/etc/objects/splash1.o b/kernel/etc/objects/splash1.o index 8b17db185239ff2b5075235f4466069416fe7dd5..3950cc4408f559ace280b54acff7d1fce0950b06 100644 GIT binary patch delta 1717 zcmah~T}Wd`6h0=mCidng(I%Sc-D(UzDArXU#NrRD)fZXZXw)cD>rX&yK?Hw_!JnWb ziYPG@chCk@RBBW-(Ta+{EP@t%@(1><^q~}=%!AN}KD0T5xlN_Z9+-P)&YU@OzVn@# zdGG0Y@9A-p2qGhL!jVr%BvBA0i6Wm8o~VdG)I>wHB$~vK&xnrbNi2yY24W=fB;jZA z+~u|?`KYKU$j;6Ny*m!0~Bm zX^@$j36YVJ^iP-gh2PT8zx_qvG{?us;BYu#V`Bq4Iy&gXrJy%IQ$n~@R8&BJe?J}i zQf*Y^=jVgd>2w!m$y-}n-9;(X*BNwrbaVv6!^6P$<}3Wo0GY-rj=UZfAj@(quA0Lqh}9*46@MJtRR`H1SF>(N``FM^#?Yz(8Sw ztp^7Oz;Rs26n1uYz-%_d!oq^2!%kgY9kjQ%OS+__qz~CJP~Rb_o0}V!PwbD6kAutQ zVh%DgGGKdq8;XmI!Dh38&*wvi0reLb7m%Bq3!*3j0>?EaB_&W_Uk|&xyKFtqEiW&F zAPDG#{#~UthJ&;7)c3iD`wA0*g6q4wx>%wnCnuRM^eHVZg@J*A(D1npwdHGHyurdi z!K`9X*pLYXhIEI^+S(e#$H%h(F;L7dHe|56x*ARCmP4(lmO+6tt5ho3+S&r1=NbR| z`}?rCxCl*6O)xe#2Gi5i^rcIqf1=IKzfmfcj3somy1EK#wVK6){cu4KxMxT(=Kryw z55Eigp%B2FoE*RmVM|R-WdNUN44K3OeR6UF6B84RS=3=GC@5h2A&ihDBqYH4`Z|n` zj)K$agzM{Tz;hE97YFzE_aKwWv>{tqT3SNt>0hg2s^8Ma+eSu4STd%jrX(Y*11vxk zteeBbLx_!yW#gbX_Wy_t{m~e)VhYCDhF)=ZcEd~`G9gUDtN9A78geYlJr<$_{0s#pYPA4WN zGNxBnR+y)!P@yk0NN&(Fi&-kx;HU>VQO&H|P#7T(Ov49Mkj z=De@3kDbll-dSg6Q2Rs`O)$RbKgN(w8jxw$#;`~B>qLjBd%6&5xf`2%4Ro;J=2 z9PNIm*0S6E?W3roo$u7T&?ub-dV&V8A4M&`290UK>nih6)X~mwgKq(Pd=mQWOMEbt W> z`(coANziW5h!EFtd1Ci@US!^6-$pX?w)?Pu)z05(Tgf@6s?Is}SJnBd{tq+O4>Q(Y z=E7W=h6&7#xic;EV4lp2iOicxOvm)hzF$ry)6+09F##`Lynw^QLkI{60B7>^^Mn2UeR%ouC5(@c!~Fa_xVpOXN3(Jq z_qWM`!xmXvT3QNvy?)pnqVMeNgsG`1=<4di!7D2iFRR{4f_7_b3rr@H-P|lb$;rua z{s`(pi2_PWN&qdWl$e+Zv$M0RNGp1ql9J-kwYIiGMMVXFXOrWqkB*K&6h$a2D}&0) zNI%Zb!sy22>+$H(|srb3NI1A&2oG$cu) zgBY=bZpS6`4kHZ@52qC$2L~G3+1a6UGcz+F%QAmgtTU!3B_+YYzyNJnEEcG*uZQmL zZUQ&T&Xk^>PN_p38r|L9wVSPC;p*xtVEweWw}aVirYq=#^CP1Yk>gDNf6S1O5Lj4P zplF{W6kor7O#|N&2`kPyg&rOrfN4d?@U8p%`yJ!?^XGKuYqZ4UgwVz3>Fw=>k&zJ? z8yn+=ZzbdR&fZ{6+}+&)Vi=ux^X3iQ-rf@L@sa z^@>EL4bX~?6&Dw)M__Pp5VEtg)iZqACWrT6q}A2cjzb8uwzf9V>2wGPaCdj7J;a33 zXe1t^ii(PI+&MTnaPU~HN~ECGYN>Om8<^#jlM@orK^zJ;{BfcY5fK3hG6c-W9}Gsj zrAo}bzP^U?@^aM(t=Lx(VF(7SWG^o-(%;aDYWA|KJTcdMd`xbxnmmJrlAPG7; zI$&{e5o|UaaLx&`XaRG&x3@>F6pJt|EsYFg{?E?N2$7hE=H_N+7R%vHq|H zZ*FeF($W&84iS$HR1I4(#s~Ivp1k*G