diff --git a/QemuVGADriver/src/QemuVga.c b/QemuVGADriver/src/QemuVga.c
index 4584242..9dbf082 100644
--- a/QemuVGADriver/src/QemuVga.c
+++ b/QemuVGADriver/src/QemuVga.c
@@ -18,9 +18,25 @@ static struct vMode vModes[] =  {
  	{ 1600, 1200 },
  	{ 1920, 1080 },
  	{ 1920, 1200 },
-	{ 0,0 }
+	{ 0,0 },
+	{ 0,0 },
+	{ 0,0 },
+	{ 0,0 },
+	{ 0,0 },
+	{ 0,0 },
+	{ 0,0 },
+	{ 0,0 },
+	{ 0,0 },
+	{ 0,0 },
+	{ 0,0 },
+	{ 0,0 },
+	{ 0,0 },
  };

+/* The number of width-height pairs in the above vModes structure */
+#define AVAILABLE_SLOTS 20
+
+
  static void VgaWriteB(UInt16 port, UInt8 val)
  {
  	UInt8 *ptr;
@@ -148,11 +164,249 @@ static InterruptMemberNumber  
PCIInterruptHandler(InterruptSetMember ISTmember,
  #endif


+/* Returns the number of resolutions in the vModes array */
+static int get_number_of_resolutions()
+{
+	int size_of_array, num_of_resolutions, index;
+	
+	num_of_resolutions = 0;
+	size_of_array = sizeof(vModes) / sizeof(struct vMode);
+	
+	for(index = 0; index < size_of_array; index++)
+	{
+		if (vModes[index].width != 0) {
+			num_of_resolutions++;
+		}
+	}
+	
+	return num_of_resolutions;
+}
+
+
+/* convert ascii string to number */
+static int atoi(const char *str)
+{
+    int result = 0;
+    while (*str) {
+        result = result * 10 + *str - '0';
+        str++;
+    }
+    return result;
+}
+
+
+/* An interesting way of emulating memory allocation. */
+static char *malloc(size_t size)
+{
+	const int max_buffer_size = 2000;
+	static char buffer[max_buffer_size];
+	static int free_mem_pointer = 0;
+	static Boolean first_alloc = true;
+	
+	free_mem_pointer += size;
+	if (free_mem_pointer >= max_buffer_size) {
+		return NULL;
+	}
+	
+	/* For getting the very beginning of the buffer */
+	if (first_alloc == true) {
+		first_alloc = false;
+		return buffer;
+	}
+
+	return (buffer + free_mem_pointer);
+}
+
+
+/* Get the resolution set at the specified index. */
+static char *get_resolution_set(const char *resolution_set_str, int  
set_number)
+{
+	const int max_buf_size = 100;
+	char c, *buffer;
+	int index, comma_count;
+
+	buffer = (char *) malloc(max_buf_size);
+	comma_count = 0;
+	index = 0;
+	set_number++; /* Makes things easier to understand */
+
+	c = *(resolution_set_str++);
+	while (c != '\0') {
+		buffer[index++] = c;
+		c = *(resolution_set_str++);
+		if (c == ',') {
+			comma_count++;
+			if (comma_count == set_number || index >= max_buf_size) {
+				buffer[index] = '\0';
+				return buffer;
+			}
+			
+			else {
+				/* reset the buffer */
+				index = 0;
+				c = *(resolution_set_str++);
+			}
+		}
+	}
+	
+	buffer[index] = '\0';
+
+	return buffer;
+}
+
+
+/* Get the number of resolution sets - a set is a width by height  
pair */
+static int get_resolution_set_count(const char *resolution_sets_str)
+{
+	char c;
+	int count;
+	
+	/* Count the number of commas */
+	count = 0;
+	c = *(resolution_sets_str++);
+	while (c != '\0') {
+		if (c == ',') {
+			count++;
+		}
+		c = *(resolution_sets_str++);
+	}
+
+	return count + 1;
+}
+
+
+/*
+ * Returns the width value of a resolution set
+ * Example:
+ * input: 16000x9000
+ * output: 16000
+ */
+static int get_width(const char *resolution_str)
+{
+	int index;
+	char c;
+	const int max_buf_size = 25;
+	char buffer[max_buf_size];
+	c = *(resolution_str++);
+	index = 0;
+	while (c != 'x' && index < max_buf_size) {
+		buffer[index++] = c;
+		c = *(resolution_str++);
+	}
+	
+	/* Terminate string */
+	buffer[index] = '\0';
+	
+	return atoi(buffer);
+}
+
+
+/*
+ * Returns the height value of a resolution set
+ * Example
+ * input: 16000x9000
+ * output: 9000
+ */
+static int get_height(const char *resolution_str)
+{
+	int index;
+	char c;
+	const int max_buf_size = 25;
+	char buffer[max_buf_size];
+	
+	/* skip to character after x */
+	while (*resolution_str != 'x') {
+		resolution_str++;
+	}
+	resolution_str++;
+	
+	/* Add digits of the height to the buffer */
+	index = 0;
+	c = *(resolution_str++);
+	while (c != '\0') {
+		buffer[index++] = c;
+		c = *(resolution_str++);
+		if(index >= max_buf_size) {
+			break;
+		}
+	}
+	
+	/* Terminate string */
+	buffer[index] = '\0';
+	
+	return atoi(buffer);
+}
+
+
+/* Looks in the /options node for the value of the resolutions  
property */
+static int add_user_resolutions(void)
+{	
+	RegEntryID entry_id;
+	OSErr err;
+	OSStatus os_status = noErr;
+	Boolean is_done;
+	void *value;
+	RegPropertyValueSize property_size = -1;
+	int index, res_set_count;
+	char *set_str;
+
+	#define PROPERTY_NAME "resolutions"
+	#define NODE_PATH "Devices:device-tree:options"
+
+	/* init the entry variable */
+	err = RegistryEntryIDInit(&entry_id);
+	if (err != noErr) {
+		lprintf("Error: Failed to init entry variable! (Error: %d)\n", err);
+		return err;
+	}
+	is_done = false;
+
+	/* Get the entry ID value */
+	err = RegistryCStrEntryLookup(NULL /* start root */, NODE_PATH,  
&entry_id);
+	if (err != noErr) {
+		lprintf("RegistryCStrEntryLookup() failure (Error: %d)\n", err);
+		return err;
+	}
+
+	/* Get the size of the property */
+	os_status = RegistryPropertyGetSize(&entry_id, PROPERTY_NAME,  
&property_size);
+	if (os_status != noErr) {
+		lprintf("Error: Failed to get property size! (Error: %d)\n",  
os_status);
+		return os_status;
+	}
+
+	/* Allocate memory to the value variable */
+	value = (void *) malloc(property_size);
+
+	/* Get the value of the property */
+	err = RegistryPropertyGet(&entry_id, PROPERTY_NAME, value,  
&property_size);
+	if (err != noErr) {
+		lprintf("Error: Failed to find property value %s! (Error: %d)\n",  
PROPERTY_NAME, err);
+		return err;
+	}
+	
+	/* Limit the number of resolutions to number of available slots in  
vMode */
+	res_set_count = get_resolution_set_count(value);
+	res_set_count = (res_set_count > AVAILABLE_SLOTS ?  
AVAILABLE_SLOTS : res_set_count);
+
+	/* Add each resolution set */
+	for(index = 0; index < res_set_count; index++) {
+		set_str = get_resolution_set(value, index);
+		vModes[index].width = get_width(set_str);
+		vModes[index].height = get_height(set_str);
+	}
+
+	return 0;
+}
+
