diff --git a/core/reios/gdrom_hle.cpp b/core/reios/gdrom_hle.cpp
index 3906909b9..e3e232979 100644
--- a/core/reios/gdrom_hle.cpp
+++ b/core/reios/gdrom_hle.cpp
@@ -18,24 +18,33 @@
 #define debugf(...) DEBUG_LOG(REIOS, __VA_ARGS__)
 
 // FIXME Serialize
-u32 LastCommandId = 0xFFFFFFFF;
-u32 NextCommandId = 1;
-u32 bios_result[4];				// BIOS result vector
-u32 cur_sector;
-
-void GDROM_HLE_ReadSES(u32 addr)
+typedef enum { BIOS_ERROR = -1, BIOS_INACTIVE, BIOS_ACTIVE, BIOS_COMPLETED } gd_bios_status;
+struct gdrom_hle_state_t
 {
-	u32 s = ReadMem32(addr + 0);
-	u32 b = ReadMem32(addr + 4);
-	u32 ba = ReadMem32(addr + 8);
-	u32 bb = ReadMem32(addr + 12);
+	u32 last_request_id;
+	u32 next_request_id;
+	gd_bios_status status;
+	u32 command;
+	u32 params[4];
+	u32 result[4];
+	u32 cur_sector;
+};
+gdrom_hle_state_t gd_hle_state = { 0xffffffff, 1, BIOS_INACTIVE };
+
+static void GDROM_HLE_ReadSES()
+{
+	u32 s = gd_hle_state.params[0];
+	u32 b = gd_hle_state.params[1];
+	u32 ba = gd_hle_state.params[2];
+	u32 bb = gd_hle_state.params[3];
 
 	WARN_LOG(REIOS, "GDROM_HLE_ReadSES: doing nothing w/ %d, %d, %d, %d", s, b, ba, bb);
 }
-void GDROM_HLE_ReadTOC(u32 Addr)
+
+static void GDROM_HLE_ReadTOC()
 {
-	u32 area = ReadMem32(Addr + 0);
-	u32 dest = ReadMem32(Addr + 4);
+	u32 area = gd_hle_state.params[0];
+	u32 dest = gd_hle_state.params[1];
 
 	u32* pDst = (u32*)GetMemPtr(dest, 0);
 
@@ -43,7 +52,7 @@ void GDROM_HLE_ReadTOC(u32 Addr)
 	if (area == DoubleDensity && libGDR_GetDiscType() != GdRom)
 	{
 		// Only GD-ROM has a high-density area but no error is reported
-		LastCommandId = 0xFFFFFFFF;
+		gd_hle_state.status = BIOS_INACTIVE;
 		return;
 	}
 
@@ -55,12 +64,12 @@ void GDROM_HLE_ReadTOC(u32 Addr)
 	}
 }
 
-void read_sectors_to(u32 addr, u32 sector, u32 count) {
+static void read_sectors_to(u32 addr, u32 sector, u32 count) {
 	u8 * pDst = GetMemPtr(addr, 0);
 
 	if (pDst) {
 		libGDR_ReadSector(pDst, sector, count, 2048);
-		cur_sector = sector + count - 1;
+		gd_hle_state.cur_sector = sector + count - 1;
 	}
 	else {
 		u8 temp[2048];
@@ -76,117 +85,119 @@ void read_sectors_to(u32 addr, u32 sector, u32 count) {
 			sector++;
 			count--;
 		}
-		cur_sector = sector - 1;
+		gd_hle_state.cur_sector = sector - 1;
 	}
 }
 
-void GDROM_HLE_ReadDMA(u32 addr)
+static void GDROM_HLE_ReadDMA()
 {
-	u32 s = ReadMem32(addr + 0x00);
-	u32 n = ReadMem32(addr + 0x04);
-	u32 b = ReadMem32(addr + 0x08);
-	u32 u = ReadMem32(addr + 0x0C);
+	u32 s = gd_hle_state.params[0];
+	u32 n = gd_hle_state.params[1];
+	u32 b = gd_hle_state.params[2];
+	u32 u = gd_hle_state.params[3];
 
 	debugf("GDROM: DMA READ Sector=%d, Num=%d, Buffer=0x%08X, Unk01=0x%08X", s, n, b, u);
 	read_sectors_to(b, s, n);
-	bios_result[2] = n * 2048;
-	bios_result[3] = -n * 2048;
+	gd_hle_state.result[2] = n * 2048;
+	gd_hle_state.result[3] = -n * 2048;
 }
 
-void GDROM_HLE_ReadPIO(u32 addr)
+static void GDROM_HLE_ReadPIO()
 {
-	u32 s = ReadMem32(addr + 0x00);
-	u32 n = ReadMem32(addr + 0x04);
-	u32 b = ReadMem32(addr + 0x08);
-	u32 u = ReadMem32(addr + 0x0C);
+	u32 s = gd_hle_state.params[0];
+	u32 n = gd_hle_state.params[1];
+	u32 b = gd_hle_state.params[2];
+	u32 u = gd_hle_state.params[3];
 
 	debugf("GDROM: PIO READ Sector=%d, Num=%d, Buffer=0x%08X, Unk01=0x%08X", s, n, b, u);
 
 	read_sectors_to(b, s, n);
-	bios_result[2] = n * 2048;
-	bios_result[3] = -n * 2048;
+	gd_hle_state.result[2] = n * 2048;
+	gd_hle_state.result[3] = -n * 2048;
 }
 
-void GDCC_HLE_GETSCD(u32 addr) {
-	u32 format = ReadMem32(addr + 0x00);
-	u32 size = ReadMem32(addr + 0x04);
-	u32 dest = ReadMem32(addr + 0x08);
+static void GDCC_HLE_GETSCD() {
+	u32 format = gd_hle_state.params[0];
+	u32 size = gd_hle_state.params[1];
+	u32 dest = gd_hle_state.params[2];
 
 	INFO_LOG(REIOS, "GDROM: GETSCD format %x size %x dest %08x", format, size, dest);
 
+	if (cdda.playing)
+		gd_hle_state.cur_sector = cdda.CurrAddr.FAD;
 	u8 scd[100];
-	gd_get_subcode(format, cur_sector, scd);
+	gd_get_subcode(format, gd_hle_state.cur_sector, scd);
 	verify(scd[3] == size);
 
 	memcpy(GetMemPtr(dest, size), scd, size);
 
 	// record size of pio transfer to gdrom
-	bios_result[2] = size;
+	gd_hle_state.result[2] = size;
 }
 
 
 u32 SecMode[4];
 
-void GD_HLE_Command(u32 cc, u32 prm)
+static void GD_HLE_Command(u32 cc)
 {
+	gd_hle_state.status = BIOS_COMPLETED;
 	switch(cc)
 	{
 	case GDCC_GETTOC:
-		WARN_LOG(REIOS, "GDROM: *FIXME* CMD GETTOC PRM:%X", prm);
+		WARN_LOG(REIOS, "GDROM: *FIXME* CMD GETTOC");
 		break;
 
 	case GDCC_GETTOC2:
-		GDROM_HLE_ReadTOC(prm);
+		GDROM_HLE_ReadTOC();
 		break;
 
 	case GDCC_GETSES:
-		GDROM_HLE_ReadSES(prm);
+		GDROM_HLE_ReadSES();
 		break;
 
 	case GDCC_INIT:
-		INFO_LOG(REIOS, "GDROM: CMD INIT PRM:%X", prm);
+		INFO_LOG(REIOS, "GDROM: CMD INIT");
 		break;
 
 	case GDCC_PIOREAD:
-		GDROM_HLE_ReadPIO(prm);
+		GDROM_HLE_ReadPIO();
 		break;
 
 	case GDCC_DMAREAD:
-		GDROM_HLE_ReadDMA(prm);
+		GDROM_HLE_ReadDMA();
 		break;
 
 
 	case GDCC_PLAY_SECTOR:
-		WARN_LOG(REIOS, "GDROM: CMD PLAYSEC? PRM:%X", prm);
+		WARN_LOG(REIOS, "GDROM: CMD PLAYSEC?");
 		break;
 
 	case GDCC_RELEASE:
-		WARN_LOG(REIOS, "GDROM: CMD RELEASE? PRM:%X", prm);
+		WARN_LOG(REIOS, "GDROM: CMD RELEASE?");
 		break;
 
 	case GDCC_STOP:
-		INFO_LOG(REIOS, "GDROM: CMD STOP PRM:%X", prm);
+		INFO_LOG(REIOS, "GDROM: CMD STOP");
 		cdda.playing = false;
 		SecNumber.Status = GD_STANDBY;
 		break;
 
 	case GDCC_SEEK:
-		INFO_LOG(REIOS, "GDROM: CMD SEEK PRM:%X", prm);
+		INFO_LOG(REIOS, "GDROM: CMD SEEK");
 		cdda.playing = false;
 		SecNumber.Status = GD_PAUSE;
 		break;
 
 	case GDCC_PLAY:
 		{
-
-			u32 first_track = ReadMem32(prm);
-			u32 last_track = ReadMem32(prm + 4);
-			u32 repeats = ReadMem32(prm + 8);
+			u32 first_track = gd_hle_state.params[0];
+			u32 last_track = gd_hle_state.params[1];
+			u32 repeats = gd_hle_state.params[2];
 			u32 start_fad, end_fad, dummy;
 			libGDR_GetTrack(first_track, start_fad, dummy);
 			libGDR_GetTrack(last_track, dummy, end_fad);
 			INFO_LOG(REIOS, "GDROM: CMD PLAY first_track %x last_track %x repeats %x start_fad %x end_fad %x param4 %x", first_track, last_track, repeats,
-					start_fad, end_fad, ReadMem32(prm + 12));
+					start_fad, end_fad, gd_hle_state.params[3]);
 			cdda.playing = true;
 			cdda.StartAddr.FAD = start_fad;
 			cdda.EndAddr.FAD = end_fad;
@@ -205,23 +216,23 @@ void GD_HLE_Command(u32 cc, u32 prm)
 
 	case GDCC_READ:
 		{
-			u32 s = ReadMem32(prm + 0x00);
-			u32 n = ReadMem32(prm + 0x04);
-			u32 b = ReadMem32(prm + 0x08);
-			u32 u = ReadMem32(prm + 0x0C);
+			u32 s = gd_hle_state.params[0];
+			u32 n = gd_hle_state.params[1];
+			u32 b = gd_hle_state.params[2];
+			u32 u = gd_hle_state.params[3];
 
-			WARN_LOG(REIOS, "GDROM: CMD READ PRM:%X Sector=%d, Num=%d, Buffer=0x%08X, Unk01=%08x", prm, s, n, b, u);
+			WARN_LOG(REIOS, "GDROM: CMD READ Sector=%d, Num=%d, Buffer=0x%08X, Unk01=%08x", s, n, b, u);
 		}
 		break;
 
 	case GDCC_GETSCD:
-		GDCC_HLE_GETSCD(prm);
+		GDCC_HLE_GETSCD();
 		break;
 
 	case GDCC_REQ_MODE:
 		{
-			debugf("GDROM: REQ_MODE PRM:%X", prm);
-			u32 dest = ReadMem32(prm);
+			u32 dest = gd_hle_state.params[0];
+			debugf("GDROM: REQ_MODE dest:%x", dest);
 			u32 *out = (u32 *)GetMemPtr(dest, 16);
 			out[0] = GD_HardwareInfo.speed;
 			out[1] = (GD_HardwareInfo.standby_hi << 8) | GD_HardwareInfo.standby_lo;
@@ -229,18 +240,18 @@ void GD_HLE_Command(u32 cc, u32 prm)
 			out[3] = GD_HardwareInfo.read_retry;
 
 			// record size of pio transfer to gdrom
-			bios_result[2] = 0xa;
+			gd_hle_state.result[2] = 0xa;
 		}
 		break;
 
 	case GDCC_SET_MODE:
 		{
-			u32 speed = ReadMem32(prm);
-			u32 standby = ReadMem32(prm + 4);
-			u32 read_flags = ReadMem32(prm + 8);
-			u32 read_retry = ReadMem32(prm + 12);
+			u32 speed = gd_hle_state.params[0];
+			u32 standby = gd_hle_state.params[1];
+			u32 read_flags = gd_hle_state.params[2];
+			u32 read_retry = gd_hle_state.params[3];
 
-			debugf("GDROM: SET_MODE PRM:%X speed %x standby %x read_flags %x read_retry %x", prm, speed, standby, read_flags, read_retry);
+			debugf("GDROM: SET_MODE speed %x standby %x read_flags %x read_retry %x", speed, standby, read_flags, read_retry);
 
 			GD_HardwareInfo.speed = speed;
 			GD_HardwareInfo.standby_hi = (standby & 0xff00) >> 8;
@@ -249,13 +260,13 @@ void GD_HLE_Command(u32 cc, u32 prm)
 			GD_HardwareInfo.read_retry = read_retry;
 
 			// record size of pio transfer to gdrom
-			bios_result[2] = 0xa;
+			gd_hle_state.result[2] = 0xa;
 		}
 		break;
 
 	case GDCC_GET_VER:
 		{
-			u32 dest = ReadMem32(prm);
+			u32 dest = gd_hle_state.params[0];
 
 			debugf("GDROM: GDCC_GET_VER dest %x", dest);
 
@@ -274,10 +285,10 @@ void GD_HLE_Command(u32 cc, u32 prm)
 	case GDCC_REQ_STAT:
 		{
 			// odd, but this function seems to get passed 4 unique pointers
-			u32 dst0 = ReadMem32(prm);
-			u32 dst1 = ReadMem32(prm + 4);
-			u32 dst2 = ReadMem32(prm + 8);
-			u32 dst3 = ReadMem32(prm + 12);
+			u32 dst0 = gd_hle_state.params[0];
+			u32 dst1 = gd_hle_state.params[1];
+			u32 dst2 = gd_hle_state.params[2];
+			u32 dst3 = gd_hle_state.params[3];
 
 			debugf("GDROM: GDCC_REQ_STAT dst0=%08x dst1=%08x dst2=%08x dst3=%08x", dst0, dst1, dst2, dst3);
 
@@ -298,7 +309,7 @@ void GD_HLE_Command(u32 cc, u32 prm)
 			// ------------------------------------------------------
 			// 1-3   |  0  |  0  |  0  |  0  |  0  |  0  |  0  |  0
 			u32 elapsed;
-			u32 tracknum = libGDR_GetTrackNumber(cur_sector, elapsed);
+			u32 tracknum = libGDR_GetTrackNumber(gd_hle_state.cur_sector, elapsed);
 			WriteMem32(dst1, tracknum);
 
 			// bit   |  7  |  6  |  5  |  4  |  3  |  2  |  1  |  0
@@ -308,7 +319,7 @@ void GD_HLE_Command(u32 cc, u32 prm)
 			// ------------------------------------------------------
 			// 3    | address                | control
 			// FIXME address/control
-			u32 out = ((0x4) << 28) | ((0x1) << 24) | (cur_sector & 0x00ffffff);
+			u32 out = ((0x4) << 28) | ((0x1) << 24) | (gd_hle_state.cur_sector & 0x00ffffff);
 			WriteMem32(dst2, out);
 
 			// bit   |  7  |  6  |  5  |  4  |  3  |  2  |  1  |  0
@@ -320,11 +331,11 @@ void GD_HLE_Command(u32 cc, u32 prm)
 			WriteMem32(dst3, 1);
 
 			// record pio transfer size
-			bios_result[2] = 0xa;
+			gd_hle_state.result[2] = 0xa;
 		}
 		break;
 	default:
-		WARN_LOG(REIOS, "GDROM: Unknown GDROM CC:%X PRM:%X", cc, prm);
+		WARN_LOG(REIOS, "GDROM: Unknown GDROM CC:%X", cc);
 		break;
 	}
 }
@@ -337,70 +348,142 @@ void gdrom_hle_op()
 	{
 		switch(r[7])				// COMMAND CODE
 		{
-		case GDROM_SEND_COMMAND:	// SEND GDROM COMMAND RET: - if failed + req id
-			//debugf("GDROM: HLE SEND COMMAND CC:%X  param ptr: %X", r[4], r[5]);
-			memset(bios_result, 0, sizeof(bios_result));
-			LastCommandId = r[0] = NextCommandId++;		// Request Id
-			GD_HLE_Command(r[4], r[5]);
-			break;
-
-		case GDROM_CHECK_COMMAND:
-			if (r[4] != LastCommandId)
+		case GDROM_SEND_COMMAND:
+			// Enqueue a command for the GDROM subsystem to execute.
+			//
+			// Args:
+			//	r4 = command code
+			//	r5 = pointer to parameter block for the command, can be NULL if the command does not take parameters
+			//
+			// Returns: a request id (>=0) if successful, negative error code if failed
+			debugf("GDROM: HLE SEND COMMAND CC:%X  param ptr: %X", r[4], r[5]);
+			if (gd_hle_state.status != BIOS_INACTIVE)
 			{
-				r[0] = -1;	// Error (examine extended status information for cause of failure)
-				bios_result[0] = 5;	// Invalid command id
-				bios_result[1] = 0;
-				bios_result[2] = 0;
-				bios_result[3] = 0;
+				r[0] = 0;
 			}
 			else
 			{
-				r[0] = 2;	// Finished
+				memset(gd_hle_state.result, 0, sizeof(gd_hle_state.result));
+				gd_hle_state.last_request_id = r[0] = gd_hle_state.next_request_id++;
+				gd_hle_state.status = BIOS_ACTIVE;
+				gd_hle_state.command = r[4];
+				for (int i = 0; i < 4; i++)
+					gd_hle_state.params[i] = ReadMem32(r[5] + i * 4);
+			}
+			break;
+
+		case GDROM_CHECK_COMMAND:
+			// Check if an enqueued command has completed.
+			//
+			// Args:
+			//	r4 = request id
+			//	r5 = pointer to four 32 bit integers to receive extended status information. The first is a generic error code.
+			//
+			// Returns:
+			//	0 - no such request active
+			//	1 - request is still being processed
+			//	2 - request has completed (if queried again, you will get a 0)
+			//	3 - request was aborted(?)
+			//	-1 - request has failed (examine extended status information for cause of failure)
+			if (gd_hle_state.status != BIOS_COMPLETED && gd_hle_state.status != BIOS_ERROR)
+			{
+				r[0] = gd_hle_state.status;	// no such request active or still being processed
+			}
+			else if (r[4] != gd_hle_state.last_request_id)
+			{
+				r[0] = 0; // no such request active
+			}
+			else
+			{
+				r[0] = gd_hle_state.status;	// completed or error
+
+				//debugf("GDROM: HLE CHECK COMMAND REQID:%X  param ptr: %X -> %X", r[4], r[5], r[0]);
+				gd_hle_state.last_request_id = 0xFFFFFFFF;
+				WriteMem32(r[5], gd_hle_state.result[0]);
+				WriteMem32(r[5] + 4, gd_hle_state.result[1]);
+				WriteMem32(r[5] + 8, gd_hle_state.result[2]);
+				WriteMem32(r[5] + 12, gd_hle_state.result[3]);
+				gd_hle_state.status = BIOS_INACTIVE;
 			}
-			//debugf("GDROM: HLE CHECK COMMAND REQID:%X  param ptr: %X -> %X", r[4], r[5], r[0]);
-			LastCommandId = 0xFFFFFFFF;			// INVALIDATE CHECK CMD
-			WriteMem32(r[5], bios_result[0]);
-			WriteMem32(r[5] + 4, bios_result[1]);
-			WriteMem32(r[5] + 8, bios_result[2]);
-			WriteMem32(r[5] + 12, bios_result[3]);
 			break;
 
 		case GDROM_MAIN:
+			// In order for enqueued commands to get processed, this function must be called a few times.
 			//debugf("GDROM: HLE GDROM_MAIN");
+			if (gd_hle_state.status == BIOS_ACTIVE)
+			{
+				GD_HLE_Command(gd_hle_state.command);
+			}
 			break;
 
 		case GDROM_INIT:
+			// Initialize the GDROM subsystem. Should be called before any requests are enqueued.
 			INFO_LOG(REIOS, "GDROM: HLE GDROM_INIT");
-			LastCommandId = 0xFFFFFFFF;
+			gd_hle_state.last_request_id = 0xFFFFFFFF;
+			gd_hle_state.status = BIOS_INACTIVE;
 			break;
 
 		case GDROM_RESET:
+			// Resets the drive.
 			INFO_LOG(REIOS, "GDROM: HLE GDROM_RESET");
+			gd_hle_state.last_request_id = 0xFFFFFFFF;
+			gd_hle_state.status = BIOS_INACTIVE;
 			break;
 
 		case GDROM_CHECK_DRIVE:
+			// Checks the general condition of the drive.
+			//
+			// Args:
+			//	r4 = pointer to two 32 bit integers, to receive the drive status. The first is the current drive status, the second is the type of disc inserted (if any).
+			//	0 	Drive is busy
+			//	1 	Drive is paused
+			//	2 	Drive is in standby
+			//	3 	Drive is playing
+			//	4 	Drive is seeking
+			//	5 	Drive is scanning
+			//	6 	Drive lid is open
+			//	7 	Lid is closed, but there is no disc
+			//
+			// Returns: zero if successful, nonzero if failure
 			//debugf("GDROM: HLE GDROM_CHECK_DRIVE r4:%X", r[4]);
 			WriteMem32(r[4] + 0, 0x02);	// STANDBY
 			if (strstr(reios_device_info, "GD-ROM") != NULL)
 				WriteMem32(r[4] + 4, GdRom);
 			else
 				WriteMem32(r[4] + 4, libGDR_GetDiscType());
-			r[0] = 0;					// Success
+			r[0] = 0;
 			break;
 
 		case GDROM_ABORT_COMMAND:
+			// Tries to abort a previously enqueued command.
+			//
+			// Args:
+			//	r4 = request id
+			//
+			// Returns: zero if successful, nonzero if failure
 			INFO_LOG(REIOS, "GDROM: HLE GDROM_ABORT_COMMAND r4:%X",r[4]);
-			r[0] = -1;					// Failure
+			r[0] = -1;
 			break;
 
 
 		case GDROM_SECTOR_MODE:
+			// Sets/gets the sector format for read commands.
+			//
+			// Args:
+			//	r4 = pointer to a struct of four 32 bit integers containing new values, or to receive the old values
+			//	Field	Function
+			//	0 	Get/Set, if 0 the mode will be set, if 1 it will be queried.
+			//	1 	? (always 8192)
+			//	2 	1024 = mode 1, 2048 = mode 2, 0 = auto detect
+			//	3 	Sector size in bytes (normally 2048)
+			//
+			// Returns: zero if successful, -1 if failure
 			WARN_LOG(REIOS, "GDROM: HLE GDROM_SECTOR_MODE PTR_r4:%X",r[4]);
 			for(int i=0; i<4; i++) {
 				SecMode[i] = ReadMem32(r[4]+(i<<2));
 				INFO_LOG(REIOS, "%08X", SecMode[i]);
 			}
-			r[0] = 0;					// Success
+			r[0] = 0;
 			break;
 
 		default:
@@ -413,10 +496,20 @@ void gdrom_hle_op()
 		switch(r[7])
 		{
 		case MISC_INIT:
+			// Initializes all the syscall vectors to their default values.
+			// Returns: zero
 			WARN_LOG(REIOS, "GDROM: MISC_INIT not implemented");
+			r[0] = 0;
 			break;
 
 		case MISC_SETVECTOR:
+			// Sets/clears the handler for one of the eight superfunctions for this vector. Setting a handler is only allowed if it not currently set.
+			//
+			// Args:
+			//	r4 = superfunction number (0-7)
+			//	r5 = pointer to handler function, or NULL to clear
+			//
+			// Returns: zero if successful, -1 if setting/clearing the handler fails
 			WARN_LOG(REIOS, "GDROM: MISC_SETVECTOR not implemented");
 			break;
 
diff --git a/core/reios/gdrom_hle.h b/core/reios/gdrom_hle.h
index c6e533ec9..f5beb5f71 100644
--- a/core/reios/gdrom_hle.h
+++ b/core/reios/gdrom_hle.h
@@ -40,4 +40,3 @@
 #define CTOC_TRACK(n) (n<<16)
 
 void gdrom_hle_op();
-void GD_HLE_Command(u32 cc, u32 prm);
diff --git a/core/reios/reios.cpp b/core/reios/reios.cpp
index 21222d272..f9d4fa6a8 100644
--- a/core/reios/reios.cpp
+++ b/core/reios/reios.cpp
@@ -174,8 +174,9 @@ char* reios_disk_id() {
 static void reios_sys_system() {
 	u32 cmd = Sh4cntx.r[7];
 
-	switch (cmd) {
-		case 0:	//SYSINFO_INIT
+	switch (cmd)
+	{
+	case 0:	//SYSINFO_INIT
 		{
 			debugf("reios_sys_system: SYSINFO_INIT");
 			// 0x00-0x07: system_id
@@ -198,30 +199,21 @@ static void reios_sys_system() {
 		}
 		break;
 
-		case 2: //SYSINFO_ICON 
-		{
-			debugf("reios_sys_system: SYSINFO_ICON");
-			// r4 = icon number (0-9, but only 5-9 seems to really be icons)
-			// r5 = destination buffer (704 bytes in size)
-			Sh4cntx.r[0] = 704;
-		}
+	case 2: //SYSINFO_ICON
+		debugf("reios_sys_system: SYSINFO_ICON");
+		// r4 = icon number (0-9, but only 5-9 seems to really be icons)
+		// r5 = destination buffer (704 bytes in size)
+		Sh4cntx.r[0] = 704;
 		break;
 
-		case 3: //SYSINFO_ID 
-		{
-			debugf("reios_sys_system: SYSINFO_ID");
-//			WriteMem32(SYSINFO_ID_ADDR + 0, 0xe1e2e3e4);
-//			WriteMem32(SYSINFO_ID_ADDR + 4, 0xe5e6e7e8);
-//
-//			Sh4cntx.r[0] = SYSINFO_ID_ADDR;
-			// TODO or this?
-			Sh4cntx.r[0] = 0x8c000068;
-		}
+	case 3: //SYSINFO_ID
+		debugf("reios_sys_system: SYSINFO_ID");
+		Sh4cntx.r[0] = 0x8c000068;
 		break;
 
-		default:
-			WARN_LOG(REIOS, "reios_sys_system: unhandled cmd %d", cmd);
-			break;
+	default:
+		WARN_LOG(REIOS, "reios_sys_system: unhandled cmd %d", cmd);
+		break;
 	}
 }
 
@@ -263,8 +255,8 @@ static void reios_sys_flashrom() {
 					r5 = pointer to two 32 bit integers to receive the result.
 						The first will be the offset of the partition start, in bytes from the start of the flashrom.
 						The second will be the size of the partition, in bytes.
-					returns:
-					r0 = 0 if partition found, -1 if error or not found
+					Returns:
+					r0 = 0 if successful, -1 if no such partition exists
 				 */
 
 				u32 part = Sh4cntx.r[4];
@@ -290,8 +282,8 @@ static void reios_sys_flashrom() {
 					r4 = read start position, in bytes from the start of the flashrom
 					r5 = pointer to destination buffer
 					r6 = number of bytes to read
-					returns:
-					r0 = number of bytes read
+					Returns:
+					r0 = number of read bytes if successful, -1 if read failed
 				*/
 				u32 offset = Sh4cntx.r[4];
 				u32 dest = Sh4cntx.r[5];
@@ -312,8 +304,8 @@ static void reios_sys_flashrom() {
 					r4 = write start position, in bytes from the start of the flashrom
 					r5 = pointer to source buffer
 					r6 = number of bytes to write
-					returns:
-					r0 = number of bytes written
+					Returns:
+					r0 = number of written bytes if successful, -1 if write failed
 				*/
 
 				u32 offs = Sh4cntx.r[4];
@@ -332,7 +324,11 @@ static void reios_sys_flashrom() {
 
 		case 3:	//FLASHROM_DELETE
 			{			
-				// offset of partition to delete
+				/*
+				   r4 = offset of the start of the partition you want to delete, in bytes from the start of the flashrom
+				   Returns:
+				   r0 = zero if successful, -1 if delete failed
+				*/
 				u32 offset = Sh4cntx.r[4];
 
 				debugf("reios_sys_flashrom: FLASHROM_DELETE offs %x", offset);
@@ -382,38 +378,38 @@ static void gd_do_bioscall()
 		int func1, func2, arg1, arg2;
 	*/
 
-	switch (Sh4cntx.r[7]) {
-	case 0:	//gdGdcReqCmd, wth is r6 ?
-		GD_HLE_Command(Sh4cntx.r[4], Sh4cntx.r[5]);
-		Sh4cntx.r[0] = 0xf344312e;
-		break;
-
-	case 1:	//gdGdcGetCmdStat, r4 -> id as returned by gdGdcReqCmd, r5 -> buffer to get status in ram, r6 ?
-		Sh4cntx.r[0] = 0; //All good, no status info
-		break;
-
-	case 2: //gdGdcExecServer
-		//nop? returns something, though.
-		//Bios seems to be based on a cooperative threading model
-		//this is the "context" switch entry point
-		break;
-
-	case 3: //gdGdcInitSystem
-		//nop? returns something, though.
-		break;
-	case 4: //gdGdcGetDrvStat
-		/*
-			Looks to same as GDROM_CHECK_DRIVE
-		*/
-		WriteMem32(Sh4cntx.r[4] + 0, 0x02);	// STANDBY
-		WriteMem32(Sh4cntx.r[4] + 4, 0x80);	// CDROM | 0x80 for GDROM
-		Sh4cntx.r[0] = 0;					// RET SUCCESS
-		break;
-
-	default:
-		INFO_LOG(REIOS, "gd_do_bioscall: (%d) %d, %d, %d", Sh4cntx.r[4], Sh4cntx.r[5], Sh4cntx.r[6], Sh4cntx.r[7]);
-		break;
-	}
+//	switch (Sh4cntx.r[7]) {
+//	case 0:	//gdGdcReqCmd, wth is r6 ?
+//		GD_HLE_Command(Sh4cntx.r[4], Sh4cntx.r[5]);
+//		Sh4cntx.r[0] = 0xf344312e;
+//		break;
+//
+//	case 1:	//gdGdcGetCmdStat, r4 -> id as returned by gdGdcReqCmd, r5 -> buffer to get status in ram, r6 ?
+//		Sh4cntx.r[0] = 0; //All good, no status info
+//		break;
+//
+//	case 2: //gdGdcExecServer
+//		//nop? returns something, though.
+//		//Bios seems to be based on a cooperative threading model
+//		//this is the "context" switch entry point
+//		break;
+//
+//	case 3: //gdGdcInitSystem
+//		//nop? returns something, though.
+//		break;
+//	case 4: //gdGdcGetDrvStat
+//		/*
+//			Looks to same as GDROM_CHECK_DRIVE
+//		*/
+//		WriteMem32(Sh4cntx.r[4] + 0, 0x02);	// STANDBY
+//		WriteMem32(Sh4cntx.r[4] + 4, 0x80);	// CDROM | 0x80 for GDROM
+//		Sh4cntx.r[0] = 0;					// RET SUCCESS
+//		break;
+//
+//	default:
+//		INFO_LOG(REIOS, "gd_do_bioscall: (%d) %d, %d, %d", Sh4cntx.r[4], Sh4cntx.r[5], Sh4cntx.r[6], Sh4cntx.r[7]);
+//		break;
+//	}
 	
 	//gdGdcInitSystem
 }
diff --git a/shell/android-studio/reicast/build.gradle b/shell/android-studio/reicast/build.gradle
index f097fd3ea..8c4640f1e 100644
--- a/shell/android-studio/reicast/build.gradle
+++ b/shell/android-studio/reicast/build.gradle
@@ -38,7 +38,7 @@ android {
 
         ndk {
             moduleName "dc"
-                abiFilters 'armeabi-v7a', 'arm64-v8a'
+                abiFilters 'armeabi-v7a', 'arm64-v8a'//, 'x86'
         }
     }
 
@@ -70,6 +70,7 @@ android {
     flavorDimensions "systemtype"
     productFlavors {
         dreamcast {
+            externalNativeBuild { ndkBuild { arguments ("-j" + Runtime.runtime.availableProcessors()) } }
         }
     }
 
@@ -82,6 +83,12 @@ android {
     lintOptions {
         abortOnError false
     }
+    
+	//packagingOptions{
+	//    doNotStrip "*/armeabi/*.so"
+	//    doNotStrip "*/armeabi-v7a/*.so"
+	//    doNotStrip "*/arm64-v8a/*.so"
+	//}
 }
 
 afterEvaluate {
diff --git a/shell/android-studio/reicast/src/main/res/drawable-xhdpi/ic_banner.png b/shell/android-studio/reicast/src/main/res/drawable-xhdpi/ic_banner.png
index 557821804..0caf63d40 100644
Binary files a/shell/android-studio/reicast/src/main/res/drawable-xhdpi/ic_banner.png and b/shell/android-studio/reicast/src/main/res/drawable-xhdpi/ic_banner.png differ