diff --git a/src/audio.cpp b/src/audio.cpp
index f6096aec..a8deb291 100644
--- a/src/audio.cpp
+++ b/src/audio.cpp
@@ -42,7 +42,7 @@ STATIC_INLINE bool isaudio (void)
 
 STATIC_INLINE bool usehacks(void)
 {
-	return currprefs.cpu_model >= 68020 || currprefs.m68k_speed != 0;
+	return !(currprefs.cs_hacks & 8) && (currprefs.cpu_model >= 68020 || currprefs.m68k_speed != 0 || (currprefs.cs_hacks & 4));
 }
 
 #define SINC_QUEUE_MAX_AGE 2048
diff --git a/src/blitter.cpp b/src/blitter.cpp
index 6ba05099..f5f0f223 100644
--- a/src/blitter.cpp
+++ b/src/blitter.cpp
@@ -355,10 +355,12 @@ static void check_channel_mods (int hpos, int ch)
 // (or cycle where last D write would have been if
 // ONEDOT was active)
 
-static void blitter_interrupt (void)
+static void blitter_interrupt (int done)
 {
 	if (blit_interrupt)
 		return;
+	if (!done && (!blitter_cycle_exact || immediate_blits || currprefs.cpu_model >= 68030 || currprefs.cachesize || currprefs.m68k_speed < 0))
+		return;
 	blit_interrupt = 1;
 	send_interrupt (6);
 }
@@ -367,7 +369,7 @@ static void blitter_done (int hpos)
 {
 	ddat1use = ddat2use = 0;
 	bltstate = blit_startcycles == 0 || !blitter_cycle_exact || immediate_blits ? BLT_done : BLT_init;
-	blitter_interrupt ();
+	blitter_interrupt (1);
 	blitter_done_notify (hpos);
 	event2_remevent (ev2_blitter);
 	unset_special (SPCFLAG_BLTNASTY);
@@ -855,6 +857,15 @@ void decide_blitter (int hpos)
 			blitter_doit();
 		return;
 	}
+
+	if (bltstate == BLT_done)
+		return;
+
+	if (!blitter_cycle_exact)
+		return;
+
+	if (hpos < 0)
+		hpos = maxhpos;
 }
 
 static void blitter_force_finish(void)
diff --git a/src/cfgfile.cpp b/src/cfgfile.cpp
index 5888edf0..ea9b3f6e 100644
--- a/src/cfgfile.cpp
+++ b/src/cfgfile.cpp
@@ -2097,7 +2097,7 @@ void cfgfile_save_options(struct zfile* f, struct uae_prefs* p, int type)
 	}
 	else
 	{
-		cfgfile_write_str(f, _T("cpu_speed"), (p->m68k_speed > -30 ? (p->m68k_speed < 0 ? _T("max") : _T("real")) : "turbo"));
+		cfgfile_write_str(f, _T("cpu_speed"), p->m68k_speed < 0 ? _T("max") : _T("real"));
 	}
 
 	/* do not reorder start */
@@ -4630,14 +4630,8 @@ static int cfgfile_parse_hardware(struct uae_prefs* p, const TCHAR* option, TCHA
 		return 1;
 	}
 
-	if (cfgfile_strval(option, value, _T("cpu_speed"), &p->m68k_speed, speedmode, 1))
-	{
-		if (_tcsicmp(value, _T("max")) == 0)
-			p->m68k_speed = -1;
-		else if (_tcsicmp(value, _T("turbo")) == 0)
-			p->m68k_speed = -30;
-		else
-			p->m68k_speed--;
+	if (cfgfile_strval(option, value, _T("cpu_speed"), &p->m68k_speed, speedmode, 1)) {
+		p->m68k_speed--;
 		return 1;
 	}
 	if (cfgfile_intval(option, value, _T("cpu_speed"), &p->m68k_speed, 1))
@@ -4645,6 +4639,12 @@ static int cfgfile_parse_hardware(struct uae_prefs* p, const TCHAR* option, TCHA
 		p->m68k_speed *= CYCLE_UNIT;
 		return 1;
 	}
+	if (cfgfile_doubleval(option, value, _T("cpu_throttle"), &p->m68k_speed_throttle)) {
+		return 1;
+	}
+	if (cfgfile_doubleval(option, value, _T("cpu_x86_throttle"), &p->x86_speed_throttle)) {
+		return 1;
+	}
 	if (cfgfile_intval(option, value, _T("finegrain_cpu_speed"), &p->m68k_speed, 1))
 	{
 		if (OFFICIAL_CYCLE_UNIT > CYCLE_UNIT)
@@ -4654,8 +4654,9 @@ static int cfgfile_parse_hardware(struct uae_prefs* p, const TCHAR* option, TCHA
 		}
 		if (_tcsicmp(value, _T("max")) == 0)
 			p->m68k_speed = -1;
-		if (_tcsicmp(value, _T("turbo")) == 0)
-			p->m68k_speed = -30;
+		return 1;
+	}
+	if (cfgfile_doubleval(option, value, _T("blitter_throttle"), &p->blitter_speed_throttle)) {
 		return 1;
 	}
 
diff --git a/src/custom.cpp b/src/custom.cpp
index 1f91bfac..a97e6bfb 100644
--- a/src/custom.cpp
+++ b/src/custom.cpp
@@ -47,10 +47,6 @@
 extern int speedup_cycles_jit_pal;
 extern int speedup_cycles_jit_ntsc;
 extern int speedup_cycles_nonjit;
-extern int speedup_timelimit_jit;
-extern int speedup_timelimit_nonjit;
-extern int speedup_timelimit_jit_turbo;
-extern int speedup_timelimit_nonjit_turbo;
 #endif
 
 STATIC_INLINE bool nocustom (void)
@@ -80,7 +76,6 @@ static void uae_abort (const TCHAR *format,...)
 
 #ifdef AMIBERRY
 int pissoff_value = speedup_cycles_jit_pal * CYCLE_UNIT;
-int speedup_timelimit = speedup_timelimit_jit;
 #endif
 
 static unsigned int n_consecutive_skipped = 0;
@@ -484,23 +479,14 @@ void set_speedup_values(void)
 {
 	if (currprefs.m68k_speed < 0) {
 		if (currprefs.cachesize) {
-			pissoff_value = ((vblank_hz > 55) ? speedup_cycles_jit_ntsc : speedup_cycles_jit_pal) * CYCLE_UNIT;
-			if (currprefs.m68k_speed != -30)
-				speedup_timelimit = speedup_timelimit_jit;
-			else
-				speedup_timelimit = speedup_timelimit_jit_turbo;
+			pissoff_value = (vblank_hz > 55 ? speedup_cycles_jit_ntsc : speedup_cycles_jit_pal) * CYCLE_UNIT;
 		}
 		else {
 			pissoff_value = speedup_cycles_nonjit * CYCLE_UNIT;
-			if (currprefs.m68k_speed != -30)
-				speedup_timelimit = speedup_timelimit_nonjit;
-			else
-				speedup_timelimit = speedup_timelimit_nonjit_turbo;
 		}
 	}
 	else {
 		pissoff_value = 0;
-		speedup_timelimit = 0;
 	}
 }
 #endif
@@ -7409,10 +7395,10 @@ void init_hardware_for_drawing_frame (void)
 	next_sprite_forced = 1;
 }
 
-static int rpt_vsync ()
+static int rpt_vsync (int adjust)
 {
 	frame_time_t curr_time = read_processor_time ();
-	int v = curr_time - vsyncwaittime;
+	int v = curr_time - vsyncwaittime + adjust;
 	if (v > syncbase || v < -syncbase) {
 		vsyncmintime = vsyncmaxtime = vsyncwaittime = curr_time;
 		v = 0;
@@ -7556,12 +7542,12 @@ static bool framewait(void)
 			t = read_processor_time() - start;
 		}
 		while (true) {
-			auto v = rpt_vsync() / (syncbase / 1000.0);
+			auto v = rpt_vsync(0) / (syncbase / 1000.0);
 				if (v >= -2)
 					break;
 			cpu_sleep_millis(1);
 		}
-		while (rpt_vsync() < 0) {
+		while (rpt_vsync(0) < 0) {
 		}
 		idletime += read_processor_time() - start;
 		curr_time = read_processor_time();
@@ -7654,6 +7640,42 @@ static void fpscounter (bool frameok)
 static void vsync_handler_pre (void)
 {
 	struct amigadisplay *ad = &adisplays;
+
+	if (currprefs.m68k_speed < 0) {
+		if (regs.stopped) {
+			if (cpu_last_stop_vpos >= 0) {
+				cpu_stopped_lines += maxvpos - cpu_last_stop_vpos;
+			}
+			else {
+				cpu_stopped_lines = 0;
+			}
+		}
+		int mv = 12 - currprefs.cpu_idle / 15;
+		if (mv >= 1 && mv <= 11) {
+			mv = 11 - mv;
+			if (cpu_stopped_lines >= maxvpos * (mv * 10) / 100) {
+				cpu_sleepmode_cnt++;
+				if (cpu_sleepmode_cnt >= 50) {
+					cpu_sleepmode_cnt = 50;
+					if (!cpu_sleepmode) {
+						cpu_sleepmode = 1;
+						//write_log(_T("sleep\n"));
+					}
+				}
+			}
+			else {
+				reset_cpu_idle();
+			}
+		}
+		else {
+			reset_cpu_idle();
+		}
+	}
+	if (regs.halted < 0)
+		reset_cpu_idle();
+	cpu_last_stop_vpos = 0;
+	cpu_stopped_lines = 0;
+	
 	if (bogusframe > 0)
 		bogusframe--;
 
@@ -7662,7 +7684,8 @@ static void vsync_handler_pre (void)
 		timehack_alive--;
 
 #ifdef PICASSO96
-	rtg_vsync ();
+	if (isvsync_rtg() >= 0)
+		rtg_vsync ();
 #endif
 
 	if (!vsync_rendered) {
@@ -8228,33 +8251,143 @@ static void hsync_handler_post (bool onvsync)
 		lof_lastline = lof_store != 0;
 	}
 
+	if (currprefs.chipset_mask & CSMASK_ECS_AGNUS) {
+		if (vpos == sprhstrt) {
+			hhspr = 1;
+		}
+		if (vpos == sprhstop) {
+			hhspr = 0;
+		}
+		if (vpos == bplhstrt) {
+			hhbpl = 1;
+		}
+		if (vpos == bplhstop) {
+			hhbpl = 0;
+		}
+		uae_u16 add = maxhpos + lol - 1;
+		uae_u16 max = (new_beamcon0 & 0x040) ? htotal : add;
+		uae_u16 hhpos_old = hhpos;
+		hhpos += add;
+		if (hhpos_old <= max || hhpos >= 0x100) {
+			if (max)
+				hhpos %= max;
+			else
+				hhpos = 0;
+		}
+		if (hhpos_hpos) {
+			hhpos -= add - hhpos_hpos;
+			hhpos_hpos = 0;
+		}
+		hhpos &= 0xff;
+	}
+
+#ifdef CPUEMU_13
+	if (currprefs.cpu_memory_cycle_exact || currprefs.blitter_cycle_exact) {
+		int hp = maxhpos - 1, i;
+		for (i = 0; i < 4; i++) {
+			alloc_cycle(hp, i == 0 ? CYCLE_STROBE : CYCLE_REFRESH); /* strobe */
+#ifdef DEBUGGER
+			if (debug_dma) {
+				uae_u16 strobe = 0x3c;
+				if (vpos < equ_vblank_endline)
+					strobe = 0x38;
+				else if (vpos < minfirstline)
+					strobe = 0x3a;
+				else if (vpos + 1 == maxvpos + lof_store)
+					strobe = 0x38;
+				else if ((currprefs.chipset_mask & CSMASK_ECS_AGNUS) && lol)
+					strobe = 0x3e;
+				record_dma(i == 0 ? strobe : 0x1fe, 0xffff, 0xffffffff, hp, vpos, DMARECORD_REFRESH, i);
+			}
+#endif
+			hp += 2;
+			if (hp >= maxhpos)
+				hp -= maxhpos;
+		}
+	}
+#endif
+	
 	events_dmal_hsync ();
 
-	if (currprefs.m68k_speed < 0) {
+	if (!currprefs.cpu_thread && !cpu_sleepmode && currprefs.m68k_speed < 0 && !currprefs.cpu_memory_cycle_exact) {
+
+		static int sleeps_remaining;
 		if (is_last_line()) {
-			/* really last line, just run the cpu emulation until whole vsync time has been used */
-			vsyncmintime = vsyncmaxtime; /* emulate if still time left */
-			if (vsyncmaxtime - read_processor_time() > -speedup_timelimit)
+			sleeps_remaining = (165 - currprefs.cpu_idle) / 6;
+			if (sleeps_remaining < 0)
+				sleeps_remaining = 0;
+			if (regs.stopped && currprefs.cpu_idle) {
+				// CPU in STOP state: sleep if enough time left.
+				frame_time_t rpt = read_processor_time();
+				while ((int)vsyncmintime - (int)(rpt + vsynctimebase / 10) > 0 && (int)vsyncmintime - (int)rpt < vsynctimebase) {
+					//maybe_process_pull_audio();
+
+					if (cpu_sleep_millis(1) < 0)
+						break;
+					rpt = read_processor_time();
+				}
+			}
+			else if (currprefs.m68k_speed_throttle) {
+				vsyncmintime = read_processor_time(); /* end of CPU emulation time */
+				events_reset_syncline();
+				//maybe_process_pull_audio();
+			}
+			else {
+				/* really last line, just run the cpu emulation until whole vsync time has been used */
+				vsyncmintime = vsyncmaxtime; /* emulate if still time left */
+				is_syncline_end = read_processor_time() + vsynctimebase; /* far enough in future, we never wait that long */
 				is_syncline = -12;
+			}
 		}
+
 		else {
+			static int linecounter;
 			/* end of scanline, run cpu emulation as long as we still have time */
 			vsyncmintime += vsynctimeperline;
+			linecounter++;
 			events_reset_syncline();
 			if (int(vsyncmaxtime) - int(vsyncmintime) > 0) {
 				if (int(vsyncwaittime) - int(vsyncmintime) > 0) {
 					frame_time_t rpt = read_processor_time();
 					/* Extra time left? Do some extra CPU emulation */
-					if (int(vsyncmintime) - int(rpt) > -speedup_timelimit) {
-						is_syncline = -11;
+					if (int(vsyncmintime) - int(rpt) > 0) {
+						if (regs.stopped && currprefs.cpu_idle && sleeps_remaining > 0) {
+							// STOP STATE: sleep.
+							cpu_sleep_millis(1);
+							sleeps_remaining--;
+							//maybe_process_pull_audio();
+						}
+						else {
+							is_syncline = -11;
+							/* limit extra time */
+							is_syncline_end = int(rpt) + vsynctimeperline;
+							linecounter = 0;
+						}
 					}
 				}
 			}
 		}
 	}
-	else {
-		if (vpos + 1 < maxvpos + lof_store && (vpos == maxvpos_display * 1 / 3 || vpos == maxvpos_display * 2 / 3)) {
+	else if (!currprefs.cpu_thread) {
+
+		// the rest
+		static int nextwaitvpos;
+		if (vpos == 0)
+			nextwaitvpos = maxvpos_display * 1 / 4;
+		
+		if (vpos + 1 < maxvpos + lof_store && vpos >= nextwaitvpos && vpos < maxvpos - (maxvpos / 3)) {
+			nextwaitvpos += maxvpos_display * 1 / 3;
 			vsyncmintime += vsynctimeperline;
+			if (!currprefs.turbo_emulation) {
+				frame_time_t rpt = read_processor_time();
+				// sleep if more than 2ms "free" time
+				while ((int)vsyncmintime - (int)(rpt + vsynctimebase / 10) > 0 && (int)vsyncmintime - (int)rpt < vsynctimebase) {
+					//maybe_process_pull_audio();
+					if (cpu_sleep_millis(1) < 0)
+						break;
+					rpt = read_processor_time();
+				}
+			}
 		}
 	}
 
diff --git a/src/drawing.cpp b/src/drawing.cpp
index 40c99116..57ab7ee5 100644
--- a/src/drawing.cpp
+++ b/src/drawing.cpp
@@ -4204,13 +4204,13 @@ void drawing_init(void)
 	reset_drawing();
 }
 
-//int isvsync_chipset(void)
-//{
-//	struct amigadisplay *ad = &adisplays;
-//	if (ad->picasso_on)
-//		return 0;
-//	return 1;
-//}
+int isvsync_chipset(void)
+{
+	struct amigadisplay *ad = &adisplays;
+	if (ad->picasso_on)
+		return 0;
+	return 1;
+}
 
 int isvsync_rtg(void)
 {
diff --git a/src/events.cpp b/src/events.cpp
index 02dc2000..0cc28a36 100644
--- a/src/events.cpp
+++ b/src/events.cpp
@@ -12,9 +12,10 @@
 #include "options.h"
 #include "include/memory.h"
 #include "newcpu.h"
+#include "xwin.h"
 
 unsigned long int nextevent, currcycle;
-int is_syncline;
+int is_syncline, is_syncline_end;
 
 frame_time_t vsyncmintime, vsyncmaxtime, vsyncwaittime;
 int vsynctimebase;
@@ -48,19 +49,69 @@ void events_schedule(void)
 static bool event_check_vsync(void)
 {
 	/* Keep only CPU emulation running while waiting for sync point. */
-	if (is_syncline)
+	if (is_syncline == -1) {
+
+		if (!isvsync_chipset()) {
+			events_reset_syncline();
+			return false;
+		}
+	}
+	else if (is_syncline == -2) {
+
+		if (!isvsync_chipset()) {
+			events_reset_syncline();
+			return false;
+		}
+	}
+	else if (is_syncline == -3) {
+		if (!isvsync_chipset()) {
+			events_reset_syncline();
+			return false;
+		}
+	}
+	else if (is_syncline > 0)
 	{
-		int rpt = read_processor_time();
-		int v = rpt - vsyncmintime;
-		if (v > vsynctimebase || v < -vsynctimebase)
-		{
-			v = 0;
+		if (!isvsync_chipset()) {
+			events_reset_syncline();
+			return false;
 		}
-		if (v < speedup_timelimit)
-		{
-			regs.pissoff = pissoff_value;
-			return true;
+	}
+	else if (is_syncline <= -100) {
+
+		if (!isvsync_chipset()) {
+			events_reset_syncline();
+			return false;
 		}
+	}
+	else if (is_syncline == -10) {
+
+		// wait is_syncline_end
+		//if (event_wait) {
+			int rpt = read_processor_time();
+			int v = rpt - is_syncline_end;
+			if (v < 0)
+			{
+				regs.pissoff = pissoff_value;
+				return true;
+			}
+		//}
+		events_reset_syncline();
+	}
+	else if (is_syncline < -10) {
+
+		// wait is_syncline_end/vsyncmintime
+		//if (event_wait) {
+			int rpt = read_processor_time();
+			int v = rpt - vsyncmintime;
+			int v2 = rpt - is_syncline_end;
+			if (v > vsynctimebase || v < -vsynctimebase) {
+				v = 0;
+			}
+			if (v < 0 && v2 < 0) {
+				regs.pissoff = pissoff_value;
+				return true;
+			}
+		//}
 		events_reset_syncline();
 	}
 	return false;
diff --git a/src/filesys.cpp b/src/filesys.cpp
index f93beb8f..d1f05200 100644
--- a/src/filesys.cpp
+++ b/src/filesys.cpp
@@ -45,6 +45,7 @@
 #include "bsdsocket.h"
 #include "uaeresource.h"
 #include "inputdevice.h"
+#include "newcpu.h"
 #include "picasso96.h"
 #include "rommgr.h"
 
@@ -5444,99 +5445,103 @@ end:
   return 0;
 }
 
-static int handle_packet(TrapContext *ctx, Unit *unit, dpacket *pck, uae_u32 msg, int isvolume)
+static int handle_packet(TrapContext* ctx, Unit* unit, dpacket* pck, uae_u32 msg, int isvolume)
 {
+	bool noidle = false;
 	int ret = 1;
-  uae_s32 type = GET_PCK_TYPE (pck);
-  PUT_PCK_RES2 (pck, 0);
+	uae_s32 type = GET_PCK_TYPE(pck);
+	PUT_PCK_RES2(pck, 0);
 
 	if (unit->inhibited && isvolume
-	&& type != ACTION_INHIBIT && type != ACTION_MORE_CACHE
-	&& type != ACTION_DISK_INFO) {
-  	PUT_PCK_RES1 (pck, DOS_FALSE);
-  	PUT_PCK_RES2 (pck, ERROR_NOT_A_DOS_DISK);
-  	return 1;
-  }
-  if (type != ACTION_INHIBIT && type != ACTION_CURRENT_VOLUME
-	&& type != ACTION_IS_FILESYSTEM && type != ACTION_MORE_CACHE
-	&& type != ACTION_WRITE_PROTECT && type != ACTION_DISK_INFO
+		&& type != ACTION_INHIBIT && type != ACTION_MORE_CACHE
+		&& type != ACTION_DISK_INFO) {
+		PUT_PCK_RES1(pck, DOS_FALSE);
+		PUT_PCK_RES2(pck, ERROR_NOT_A_DOS_DISK);
+		return 1;
+	}
+	if (type != ACTION_INHIBIT && type != ACTION_CURRENT_VOLUME
+		&& type != ACTION_IS_FILESYSTEM && type != ACTION_MORE_CACHE
+		&& type != ACTION_WRITE_PROTECT && type != ACTION_DISK_INFO
 		&& !isvolume) {
-  	PUT_PCK_RES1 (pck, DOS_FALSE);
-		PUT_PCK_RES2 (pck, unit->ui.unknown_media ? ERROR_NOT_A_DOS_DISK : ERROR_NO_DISK);
-  	return 1;
-  }
-    
-  switch (type) {
-	  case ACTION_LOCATE_OBJECT: action_lock (ctx, unit, pck); break;
-	  case ACTION_FREE_LOCK: action_free_lock (ctx, unit, pck); break;
-	  case ACTION_COPY_DIR: action_dup_lock (ctx, unit, pck); break;
-	  case ACTION_DISK_INFO: action_disk_info (ctx, unit, pck); break;
-	  case ACTION_INFO: action_info (ctx, unit, pck); break;
-	  case ACTION_EXAMINE_OBJECT: action_examine_object (ctx, unit, pck); break;
-	  case ACTION_EXAMINE_NEXT: action_examine_next (ctx, unit, pck, false); break;
-	  case ACTION_FIND_INPUT: action_find_input (ctx, unit, pck); break;
-	  case ACTION_FIND_WRITE: action_find_write (ctx, unit, pck); break;
-	  case ACTION_FIND_OUTPUT: action_find_output (ctx, unit, pck); break;
-	  case ACTION_END: action_end (ctx, unit, pck); break;
-	  case ACTION_READ: action_read(ctx, unit, pck); break;
-	  case ACTION_WRITE: action_write (ctx, unit, pck); break;
-	  case ACTION_SEEK: action_seek (ctx, unit, pck); break;
-	  case ACTION_SET_PROTECT: action_set_protect (ctx, unit, pck); break;
-	  case ACTION_SET_COMMENT: action_set_comment (ctx, unit, pck); break;
-	  case ACTION_SAME_LOCK: action_same_lock (ctx, unit, pck); break;
-	  case ACTION_PARENT: action_parent (ctx, unit, pck); break;
-	  case ACTION_CREATE_DIR: action_create_dir (ctx, unit, pck); break;
-	  case ACTION_DELETE_OBJECT: action_delete_object (ctx, unit, pck); break;
-	  case ACTION_RENAME_OBJECT: action_rename_object (ctx, unit, pck); break;
-	  case ACTION_SET_DATE: action_set_date (ctx, unit, pck); break;
-	  case ACTION_CURRENT_VOLUME: action_current_volume (ctx, unit, pck); break;
-	  case ACTION_RENAME_DISK: action_rename_disk (ctx, unit, pck); break;
-	  case ACTION_IS_FILESYSTEM: action_is_filesystem (ctx, unit, pck); break;
-	  case ACTION_FLUSH: action_flush (ctx, unit, pck); break;
-	  case ACTION_MORE_CACHE: action_more_cache (ctx, unit, pck); break;
-	  case ACTION_INHIBIT: action_inhibit (ctx, unit, pck); break;
-	  case ACTION_WRITE_PROTECT: action_write_protect (ctx, unit, pck); break;
-     
-    /* 2.0+ packet types */
-	  case ACTION_SET_FILE_SIZE: action_set_file_size (ctx, unit, pck); break;
-	  case ACTION_EXAMINE_FH: action_examine_fh (ctx, unit, pck, false); break;
-	  case ACTION_FH_FROM_LOCK: action_fh_from_lock (ctx, unit, pck); break;
-	  case ACTION_COPY_DIR_FH: action_lock_from_fh (ctx, unit, pck); break;
-	  case ACTION_CHANGE_MODE: action_change_mode (ctx, unit, pck); break;
-	  case ACTION_PARENT_FH: action_parent_fh (ctx, unit, pck); break;
-	  case ACTION_ADD_NOTIFY: action_add_notify (ctx, unit, pck); break;
-	  case ACTION_REMOVE_NOTIFY: action_remove_notify (ctx, unit, pck); break;
-	  case ACTION_EXAMINE_ALL: ret = action_examine_all(ctx, unit, pck); break;
-	  case ACTION_EXAMINE_ALL_END: ret = action_examine_all_end(ctx, unit, pck); break;
-	  case ACTION_LOCK_RECORD: ret = action_lock_record (ctx, unit, pck, msg); break;
-	  case ACTION_FREE_RECORD: action_free_record (ctx, unit, pck); break;
+		PUT_PCK_RES1(pck, DOS_FALSE);
+		PUT_PCK_RES2(pck, unit->ui.unknown_media ? ERROR_NOT_A_DOS_DISK : ERROR_NO_DISK);
+		return 1;
+	}
+
+	switch (type) {
+	case ACTION_LOCATE_OBJECT: action_lock(ctx, unit, pck); break;
+	case ACTION_FREE_LOCK: action_free_lock(ctx, unit, pck); break;
+	case ACTION_COPY_DIR: action_dup_lock(ctx, unit, pck); break;
+	case ACTION_DISK_INFO: action_disk_info(ctx, unit, pck); break;
+	case ACTION_INFO: action_info(ctx, unit, pck); break;
+	case ACTION_EXAMINE_OBJECT: action_examine_object(ctx, unit, pck); break;
+	case ACTION_EXAMINE_NEXT: noidle = true; action_examine_next(ctx, unit, pck, false); break;
+	case ACTION_FIND_INPUT: action_find_input(ctx, unit, pck); break;
+	case ACTION_FIND_WRITE: action_find_write(ctx, unit, pck); break;
+	case ACTION_FIND_OUTPUT: action_find_output(ctx, unit, pck); break;
+	case ACTION_END: action_end(ctx, unit, pck); break;
+	case ACTION_READ: noidle = true; action_read(ctx, unit, pck); break;
+	case ACTION_WRITE: noidle = true; action_write(ctx, unit, pck); break;
+	case ACTION_SEEK: action_seek(ctx, unit, pck); break;
+	case ACTION_SET_PROTECT: action_set_protect(ctx, unit, pck); break;
+	case ACTION_SET_COMMENT: action_set_comment(ctx, unit, pck); break;
+	case ACTION_SAME_LOCK: action_same_lock(ctx, unit, pck); break;
+	case ACTION_PARENT: action_parent(ctx, unit, pck); break;
+	case ACTION_CREATE_DIR: action_create_dir(ctx, unit, pck); break;
+	case ACTION_DELETE_OBJECT: action_delete_object(ctx, unit, pck); break;
+	case ACTION_RENAME_OBJECT: action_rename_object(ctx, unit, pck); break;
+	case ACTION_SET_DATE: action_set_date(ctx, unit, pck); break;
+	case ACTION_CURRENT_VOLUME: action_current_volume(ctx, unit, pck); break;
+	case ACTION_RENAME_DISK: action_rename_disk(ctx, unit, pck); break;
+	case ACTION_IS_FILESYSTEM: action_is_filesystem(ctx, unit, pck); break;
+	case ACTION_FLUSH: action_flush(ctx, unit, pck); break;
+	case ACTION_MORE_CACHE: action_more_cache(ctx, unit, pck); break;
+	case ACTION_INHIBIT: action_inhibit(ctx, unit, pck); break;
+	case ACTION_WRITE_PROTECT: action_write_protect(ctx, unit, pck); break;
+
+		/* 2.0+ packet types */
+	case ACTION_SET_FILE_SIZE: action_set_file_size(ctx, unit, pck); break;
+	case ACTION_EXAMINE_FH: action_examine_fh(ctx, unit, pck, false); break;
+	case ACTION_FH_FROM_LOCK: action_fh_from_lock(ctx, unit, pck); break;
+	case ACTION_COPY_DIR_FH: action_lock_from_fh(ctx, unit, pck); break;
+	case ACTION_CHANGE_MODE: action_change_mode(ctx, unit, pck); break;
+	case ACTION_PARENT_FH: action_parent_fh(ctx, unit, pck); break;
+	case ACTION_ADD_NOTIFY: action_add_notify(ctx, unit, pck); break;
+	case ACTION_REMOVE_NOTIFY: action_remove_notify(ctx, unit, pck); break;
+	case ACTION_EXAMINE_ALL: noidle = true; ret = action_examine_all(ctx, unit, pck); break;
+	case ACTION_EXAMINE_ALL_END: ret = action_examine_all_end(ctx, unit, pck); break;
+	case ACTION_LOCK_RECORD: ret = action_lock_record(ctx, unit, pck, msg); break;
+	case ACTION_FREE_RECORD: action_free_record(ctx, unit, pck); break;
 
 		/* OS4 packet types */
-	  case ACTION_FILESYSTEM_ATTR: action_filesystem_attr(ctx, unit, pck); break;
-	  case ACTION_CHANGE_FILE_POSITION64: action_change_file_position64 (ctx, unit, pck); break;
-	  case ACTION_GET_FILE_POSITION64: action_get_file_position64 (ctx, unit, pck); break;
-	  case ACTION_CHANGE_FILE_SIZE64: action_change_file_size64 (ctx, unit, pck); break;
-	  case ACTION_GET_FILE_SIZE64: action_get_file_size64 (ctx, unit, pck); break;
+	case ACTION_FILESYSTEM_ATTR: action_filesystem_attr(ctx, unit, pck); break;
+	case ACTION_CHANGE_FILE_POSITION64: action_change_file_position64(ctx, unit, pck); break;
+	case ACTION_GET_FILE_POSITION64: action_get_file_position64(ctx, unit, pck); break;
+	case ACTION_CHANGE_FILE_SIZE64: action_change_file_size64(ctx, unit, pck); break;
+	case ACTION_GET_FILE_SIZE64: action_get_file_size64(ctx, unit, pck); break;
 
 		/* MOS packet types */
-	  case ACTION_SEEK64: action_seek64(ctx, unit, pck); break;
-	  case ACTION_SET_FILE_SIZE64: action_set_file_size64(ctx, unit, pck); break;
-	  case ACTION_EXAMINE_OBJECT64: action_examine_object64(ctx, unit, pck); break;
-	  case ACTION_EXAMINE_NEXT64: action_examine_next(ctx, unit, pck, true); break;
-	  case ACTION_EXAMINE_FH64: action_examine_fh(ctx, unit, pck, true); break;
-	  case ACTION_LOCK_RECORD64: ret = action_lock_record64(ctx, unit, pck, msg); break;
-	  case ACTION_FREE_RECORD64: action_free_record64(ctx, unit, pck); break;
+	case ACTION_SEEK64: action_seek64(ctx, unit, pck); break;
+	case ACTION_SET_FILE_SIZE64: action_set_file_size64(ctx, unit, pck); break;
+	case ACTION_EXAMINE_OBJECT64: action_examine_object64(ctx, unit, pck); break;
+	case ACTION_EXAMINE_NEXT64: noidle = true; action_examine_next(ctx, unit, pck, true); break;
+	case ACTION_EXAMINE_FH64: action_examine_fh(ctx, unit, pck, true); break;
+	case ACTION_LOCK_RECORD64: ret = action_lock_record64(ctx, unit, pck, msg); break;
+	case ACTION_FREE_RECORD64: action_free_record64(ctx, unit, pck); break;
 
-    /* unsupported packets */
-    case ACTION_MAKE_LINK:
-    case ACTION_READ_LINK:
-    case ACTION_FORMAT:
-		  write_log (_T("FILESYS: UNSUPPORTED PACKET %x\n"), type);
-	    return 0;
-    default:
-		  write_log (_T("FILESYS: UNKNOWN PACKET %x\n"), type);
-		  return 0;
-  }
+		/* unsupported packets */
+	case ACTION_MAKE_LINK:
+	case ACTION_READ_LINK:
+	case ACTION_FORMAT:
+		write_log(_T("FILESYS: UNSUPPORTED PACKET %x\n"), type);
+		return 0;
+	default:
+		write_log(_T("FILESYS: UNKNOWN PACKET %x\n"), type);
+		return 0;
+	}
+	if (noidle) {
+		m68k_cancel_idle();
+	}
 	return ret;
 }
 
diff --git a/src/hardfile.cpp b/src/hardfile.cpp
index b614aa9c..3cbe7b33 100644
--- a/src/hardfile.cpp
+++ b/src/hardfile.cpp
@@ -24,6 +24,7 @@
 #include "scsi.h"
 #include "gayle.h"
 #include "execio.h"
+#include "newcpu.h"
 #include "zfile.h"
 
 #define HDF_SUPPORT_NSD 1
@@ -656,6 +657,7 @@ int hdf_write (struct hardfiledata *hfd, void *buffer, uae_u64 offset, int len)
 
 static uae_u64 cmd_readx (struct hardfiledata *hfd, uae_u8 *dataptr, uae_u64 offset, uae_u64 len)
 {
+	m68k_cancel_idle();
 	gui_flicker_led (LED_HD, hfd->unitnum, 1);
 	return hdf_read (hfd, dataptr, offset, len);
 }
@@ -689,6 +691,7 @@ static uae_u64 cmd_read(TrapContext *ctx, struct hardfiledata *hfd, uaecptr data
 }
 static uae_u64 cmd_writex (struct hardfiledata *hfd, uae_u8 *dataptr, uae_u64 offset, uae_u64 len)
 {
+	m68k_cancel_idle();
 	gui_flicker_led (LED_HD, hfd->unitnum, 2);
 	return hdf_write (hfd, dataptr, offset, len);
 }
diff --git a/src/include/newcpu.h b/src/include/newcpu.h
index 423a8992..29a0886c 100644
--- a/src/include/newcpu.h
+++ b/src/include/newcpu.h
@@ -311,6 +311,8 @@ extern void check_t0_trace(void);
 #define x_do_cycles(c) do_cycles(c)
 
 extern void m68k_setstopped (void);
+extern void m68k_resumestopped(void);
+extern void m68k_cancel_idle(void);
 
 #define get_disp_ea_020(base,idx) _get_disp_ea_020(base)
 extern uae_u32 REGPARAM3 _get_disp_ea_020 (uae_u32 base) REGPARAM;
@@ -388,7 +390,7 @@ extern void exception3b (uae_u32 opcode, uaecptr addr, bool w, bool i, uaecptr p
 extern void exception2 (uaecptr addr, bool read, int size, uae_u32 fc);
 extern void cpureset (void);
 extern void cpu_halt (int id);
-extern void cpu_sleep_millis(int ms);
+extern int cpu_sleep_millis(int ms);
 
 extern void fill_prefetch (void);
 
diff --git a/src/include/xwin.h b/src/include/xwin.h
index 5e519b54..4d7aa76e 100644
--- a/src/include/xwin.h
+++ b/src/include/xwin.h
@@ -41,7 +41,7 @@ extern int vsync_isdone(frame_time_t*);
 extern void doflashscreen (void);
 //extern int flashscreen;
 extern void updatedisplayarea();
-
+extern int isvsync_chipset(void);
 extern int isvsync_rtg (void);
 extern int isvsync (void);
 
@@ -173,12 +173,4 @@ struct amigadisplay
 
 extern struct amigadisplay adisplays;
 
-STATIC_INLINE int isvsync_chipset (void)
-{
-	struct amigadisplay *ad = &adisplays;
-	if (ad->picasso_on)
-		return 0;
-	return 1;
-}
-
 #endif /* UAE_XWIN_H */
diff --git a/src/newcpu.cpp b/src/newcpu.cpp
index 62dd8148..afca78af 100644
--- a/src/newcpu.cpp
+++ b/src/newcpu.cpp
@@ -78,6 +78,8 @@ static uae_u64 fake_srp_030, fake_crp_030;
 static uae_u32 fake_tt0_030, fake_tt1_030, fake_tc_030;
 static uae_u16 fake_mmusr_030;
 
+int cpu_last_stop_vpos, cpu_stopped_lines;
+
 #if COUNT_INSTRS
 static uae_u32 instrcount[65536];
 static uae_u16 opcodenums[65536];
@@ -602,18 +604,30 @@ STATIC_INLINE uae_u32 adjust_cycles(uae_u32 cycles)
 	return res;
 }
 
+void m68k_cancel_idle(void)
+{
+	cpu_last_stop_vpos = -1;
+}
+
 static void m68k_set_stop(void)
 {
 	if (regs.stopped)
 		return;
 	regs.stopped = 1;
 	set_special(SPCFLAG_STOP);
+	if (cpu_last_stop_vpos >= 0) {
+		cpu_last_stop_vpos = vpos;
+	}
 }
 
 static void m68k_unset_stop(void)
 {
 	regs.stopped = 0;
 	unset_special(SPCFLAG_STOP);
+	if (cpu_last_stop_vpos >= 0) {
+		cpu_stopped_lines += vpos - cpu_last_stop_vpos;
+		cpu_last_stop_vpos = vpos;
+	}
 }
 
 static void activate_trace(void)
@@ -1558,9 +1572,10 @@ static void check_uae_int_request(void)
 	}
 }
 
-void cpu_sleep_millis(int ms)
+int cpu_sleep_millis(int ms)
 {
-	sleep_millis_main(ms);
+	const auto ret = sleep_millis_main(ms);
+	return ret;
 }
 
 static bool haltloop(void)
@@ -1598,8 +1613,6 @@ void doint(void)
 		set_special(SPCFLAG_DOINT);
 }
 
-static void m68k_resumestopped(void);
-
 static int do_specialties(int cycles)
 {
 	if (regs.spcflags & SPCFLAG_MODE_CHANGE)
@@ -2463,7 +2476,7 @@ actually stopping.  */
 	}
 }
 
-static void m68k_resumestopped(void)
+void m68k_resumestopped(void)
 {
 	if (!regs.stopped)
 		return;
diff --git a/src/osdep/amiberry.cpp b/src/osdep/amiberry.cpp
index 5e386e29..b34a73d0 100644
--- a/src/osdep/amiberry.cpp
+++ b/src/osdep/amiberry.cpp
@@ -127,33 +127,11 @@ void set_key_configs(struct uae_prefs* p)
 int speedup_cycles_jit_pal = 18000;
 int speedup_cycles_jit_ntsc = 15000;
 int speedup_cycles_nonjit = 1024;
-// These are set to give enough time to hit 60 fps
-// on the ASUS tinker board, and giving the rest of the
-// time to the CPU (minus the 10% reserve above).
-// As these numbers are decreased towards -(SPEEDUP_CYCLES),
-// more chipset time is given and the CPU gets slower.
-// For your platform its best to tune these to the point where
-// you hit 60FPS in NTSC and not higher.
-// Do not tune above -(SPEEDUP_CYCLES) or the emulation will
-// become unstable.
-int speedup_timelimit_jit = -10000;
-int speedup_timelimit_nonjit = -960;
-// These define the maximum CPU possible and work well with
-// frameskip on and operation at 30fps at full chipset speed
-// They give the minimum possible chipset time.  Do not make
-// these positive numbers.  Doing so may give you a 500mhz
-// 68040 but your emulation will not be able to reset at this
-// speed.
-int speedup_timelimit_jit_turbo = 0;
-int speedup_timelimit_nonjit_turbo = 0;
+
 #else
 int speedup_cycles_jit_pal = 10000;
 int speedup_cycles_jit_ntsc = 6667;
 int speedup_cycles_nonjit = 256;
-int speedup_timelimit_jit = -5000;
-int speedup_timelimit_nonjit = -5000;
-int speedup_timelimit_jit_turbo = 0;
-int speedup_timelimit_nonjit_turbo = 0;
 #endif
 
 extern void signal_segv(int signum, siginfo_t* info, void* ptr);
@@ -522,6 +500,7 @@ void target_save_options(struct zfile* f, struct uae_prefs* p)
 	cfgfile_write_bool(f, _T("amiberry.use_retroarch_menu"), p->use_retroarch_menu);
 	cfgfile_write_bool(f, _T("amiberry.use_retroarch_reset"), p->use_retroarch_reset);
 
+	cfgfile_target_dwrite(f, _T("cpu_idle"), _T("%d"), p->cpu_idle);
 #ifdef ANDROID
 	cfgfile_write(f, "amiberry.onscreen", "%d", p->onScreen);
 	cfgfile_write(f, "amiberry.onscreen_textinput", "%d", p->onScreen_textinput);
@@ -629,6 +608,8 @@ int target_parse_option(struct uae_prefs* p, const char* option, const char* val
 		return 1;
 	if (cfgfile_string(option, value, "fullscreen_toggle", p->fullscreen_toggle, sizeof p->fullscreen_toggle))
 		return 1;
+	if (cfgfile_intval(option, value, _T("cpu_idle"), &p->cpu_idle, 1))
+		return 1;
 	return 0;
 }
 
@@ -956,14 +937,6 @@ void save_amiberry_settings(void)
 	fputs(buffer, f);
 	snprintf(buffer, MAX_DPATH, "speedup_cycles_nonjit=%d\n", speedup_cycles_nonjit);
 	fputs(buffer, f);
-	snprintf(buffer, MAX_DPATH, "speedup_timelimit_jit=%d\n", speedup_timelimit_jit);
-	fputs(buffer, f);
-	snprintf(buffer, MAX_DPATH, "speedup_timelimit_nonjit=%d\n", speedup_timelimit_nonjit);
-	fputs(buffer, f);
-	snprintf(buffer, MAX_DPATH, "speedup_timelimit_jit_turbo=%d\n", speedup_timelimit_jit_turbo);
-	fputs(buffer, f);
-	snprintf(buffer, MAX_DPATH, "speedup_timelimit_nonjit_turbo=%d\n", speedup_timelimit_nonjit_turbo);
-	fputs(buffer, f);
 
 	// Paths
 	snprintf(buffer, MAX_DPATH, "path=%s\n", currentDir);
@@ -1167,10 +1140,6 @@ void load_amiberry_settings(void)
 					cfgfile_intval(option, value, "speedup_cycles_jit_pal", &speedup_cycles_jit_pal, 1);
 					cfgfile_intval(option, value, "speedup_cycles_jit_ntsc", &speedup_cycles_jit_ntsc, 1);
 					cfgfile_intval(option, value, "speedup_cycles_nonjit", &speedup_cycles_nonjit, 1);
-					cfgfile_intval(option, value, "speedup_timelimit_jit", &speedup_timelimit_jit, 1);
-					cfgfile_intval(option, value, "speedup_timelimit_nonjit", &speedup_timelimit_nonjit, 1);
-					cfgfile_intval(option, value, "speedup_timelimit_jit_turbo", &speedup_timelimit_jit_turbo, 1);
-					cfgfile_intval(option, value, "speedup_timelimit_nonjit_turbo", &speedup_timelimit_nonjit_turbo, 1);
 				}
 			}
 		}
diff --git a/src/osdep/gui/Navigation.cpp b/src/osdep/gui/Navigation.cpp
index 9a5406bb..1976a0a2 100644
--- a/src/osdep/gui/Navigation.cpp
+++ b/src/osdep/gui/Navigation.cpp
@@ -111,11 +111,11 @@ static NavigationMap navMap[] =
 	{"CPU internal", "68030", "Fastest", "68882", "FPUstrict"},
 	{"FPUstrict", "68040", "Fastest", "CPU internal", "FPUJIT"},
 	{"FPUJIT", "CPU24Bit", "Fastest", "FPUstrict", "FPUnone"},
-	{"7 Mhz", "FPUnone", "CPU and FPU", "Turbo", "14 Mhz"},
+	{"7 Mhz", "FPUnone", "CPU and FPU", "sldCpuIdle", "14 Mhz"},
 	{"14 Mhz", "FPUnone", "CPU and FPU", "7 Mhz", "25 Mhz"},
 	{"25 Mhz", "FPUnone", "CPU and FPU", "14 Mhz", "Fastest"},
-	{"Fastest", "FPUnone", "CPU and FPU", "25 Mhz", "Turbo"},
-	{"Turbo", "FPUnone", "CPU and FPU", "Fastest", "7 Mhz"},
+	{"Fastest", "FPUnone", "CPU and FPU", "25 Mhz", "sldCpuIdle"},
+	{"sldCpuIdle", "", "", "Fastest", "7 Mhz"},
 
 	// PanelChipset
 	{"OCS", "Chipset", "ChipsetExtra", "CollFull", "ECS Agnus"},
diff --git a/src/osdep/gui/PanelCPU.cpp b/src/osdep/gui/PanelCPU.cpp
index 0e858a71..d01e2a29 100644
--- a/src/osdep/gui/PanelCPU.cpp
+++ b/src/osdep/gui/PanelCPU.cpp
@@ -31,9 +31,10 @@ static gcn::CheckBox* chkFPUJIT;
 static gcn::Window* grpCPUSpeed;
 static gcn::RadioButton* opt7Mhz;
 static gcn::RadioButton* opt14Mhz;
-static gcn::RadioButton* opt28Mhz;
+static gcn::RadioButton* opt25Mhz;
 static gcn::RadioButton* optFastest;
-static gcn::RadioButton* optTurbo;
+static gcn::Label* lblCpuIdle;
+static gcn::Slider* sldCpuIdle;
 
 class CPUButtonActionListener : public gcn::ActionListener
 {
@@ -127,12 +128,10 @@ public:
 			changed_prefs.m68k_speed = M68K_SPEED_7MHZ_CYCLES;
 		else if (actionEvent.getSource() == opt14Mhz)
 			changed_prefs.m68k_speed = M68K_SPEED_14MHZ_CYCLES;
-		else if (actionEvent.getSource() == opt28Mhz)
+		else if (actionEvent.getSource() == opt25Mhz)
 			changed_prefs.m68k_speed = M68K_SPEED_25MHZ_CYCLES;
 		else if (actionEvent.getSource() == optFastest)
 			changed_prefs.m68k_speed = -1;
-		else if (actionEvent.getSource() == optTurbo)
-			changed_prefs.m68k_speed = -30;
 	}
 };
 
@@ -217,6 +216,23 @@ public:
 
 static FPUActionListener* fpuActionListener;
 
+class CPUIdleSliderActionListener : public gcn::ActionListener
+{
+public:
+	void action(const gcn::ActionEvent& actionEvent) override
+	{
+		if (actionEvent.getSource() == sldCpuIdle)
+		{
+			changed_prefs.cpu_idle = static_cast<int>(sldCpuIdle->getValue());
+			if (changed_prefs.cpu_idle > 0)
+				changed_prefs.cpu_idle = (12 - changed_prefs.cpu_idle) * 15;
+		}
+		RefreshPanelCPU();
+	}
+};
+
+static CPUIdleSliderActionListener* cpuIdleActionListener;
+
 void InitPanelCPU(const struct _ConfigCategory& category)
 {
 	cpuButtonActionListener = new CPUButtonActionListener();
@@ -224,6 +240,7 @@ void InitPanelCPU(const struct _ConfigCategory& category)
 	cpuCompActionListener = new CPUCompActionListener();
 	jitActionListener = new JITActionListener();
 	fpuActionListener = new FPUActionListener();
+	cpuIdleActionListener = new CPUIdleSliderActionListener();
 
 	optCPU68000 = new gcn::RadioButton("68000", "radiocpugroup");
 	optCPU68000->setId("68000");
@@ -321,27 +338,33 @@ void InitPanelCPU(const struct _ConfigCategory& category)
 	opt14Mhz->setId("14 Mhz");
 	opt14Mhz->addActionListener(cpuSpeedButtonActionListener);
 
-	opt28Mhz = new gcn::RadioButton("25 Mhz", "radiocpuspeedgroup");
-	opt28Mhz->setId("25 Mhz");
-	opt28Mhz->addActionListener(cpuSpeedButtonActionListener);
+	opt25Mhz = new gcn::RadioButton("25 Mhz", "radiocpuspeedgroup");
+	opt25Mhz->setId("25 Mhz");
+	opt25Mhz->addActionListener(cpuSpeedButtonActionListener);
 
 	optFastest = new gcn::RadioButton("Fastest", "radiocpuspeedgroup");
 	optFastest->setId("Fastest");
 	optFastest->addActionListener(cpuSpeedButtonActionListener);
 
-	optTurbo = new gcn::RadioButton("Turbo", "radiocpuspeedgroup");
-	optTurbo->setId("Turbo");
-	optTurbo->addActionListener(cpuSpeedButtonActionListener);
+	lblCpuIdle = new gcn::Label("CPU Idle");
+	sldCpuIdle = new gcn::Slider(0, 10);
+	sldCpuIdle->setSize(70, SLIDER_HEIGHT);
+	sldCpuIdle->setBaseColor(gui_baseCol);
+	sldCpuIdle->setMarkerLength(20);
+	sldCpuIdle->setStepLength(1);
+	sldCpuIdle->setId("sldCpuIdle");
+	sldCpuIdle->addActionListener(cpuIdleActionListener);
 
 	grpCPUSpeed = new gcn::Window("CPU Speed");
 	grpCPUSpeed->setPosition(grpFPU->getX() + grpFPU->getWidth() + DISTANCE_NEXT_X, DISTANCE_BORDER);
 	grpCPUSpeed->add(opt7Mhz, 5, 10);
 	grpCPUSpeed->add(opt14Mhz, 5, 40);
-	grpCPUSpeed->add(opt28Mhz, 5, 70);
+	grpCPUSpeed->add(opt25Mhz, 5, 70);
 	grpCPUSpeed->add(optFastest, 5, 100);
-	grpCPUSpeed->add(optTurbo, 5, 130);
+	grpCPUSpeed->add(lblCpuIdle, 5, 170);
+	grpCPUSpeed->add(sldCpuIdle, lblCpuIdle->getWidth() + 10, 170);
 	grpCPUSpeed->setMovable(false);
-	grpCPUSpeed->setSize(100, 200);
+	grpCPUSpeed->setSize(180, 250);
 	grpCPUSpeed->setTitleBarHeight(TITLEBAR_HEIGHT);
 	grpCPUSpeed->setBaseColor(gui_baseCol);
 
@@ -379,9 +402,12 @@ void ExitPanelCPU()
 
 	delete opt7Mhz;
 	delete opt14Mhz;
-	delete opt28Mhz;
+	delete opt25Mhz;
 	delete optFastest;
-	delete optTurbo;
+	delete lblCpuIdle;
+	delete sldCpuIdle;
+	delete cpuIdleActionListener;
+	
 	delete grpCPUSpeed;
 	delete cpuSpeedButtonActionListener;
 }
@@ -441,11 +467,11 @@ void RefreshPanelCPU()
 	else if (changed_prefs.m68k_speed == M68K_SPEED_14MHZ_CYCLES)
 		opt14Mhz->setSelected(true);
 	else if (changed_prefs.m68k_speed == M68K_SPEED_25MHZ_CYCLES)
-		opt28Mhz->setSelected(true);
+		opt25Mhz->setSelected(true);
 	else if (changed_prefs.m68k_speed == -1)
 		optFastest->setSelected(true);
-	else if (changed_prefs.m68k_speed == -30)
-		optTurbo->setSelected(true);
+
+	sldCpuIdle->setValue(changed_prefs.cpu_idle == 0 ? 0 : 12 - changed_prefs.cpu_idle / 15);
 }
 
 bool HelpPanelCPU(std::vector<std::string>& helptext)
@@ -463,9 +489,12 @@ bool HelpPanelCPU(std::vector<std::string>& helptext)
 	helptext.emplace_back("The option \"More compatible\" activates more accurate rounding and compare of two floats.");
 	helptext.emplace_back(" ");
 	helptext.emplace_back("With \"CPU Speed\" you can choose the clock rate of the emulated Amiga.");
-	helptext.emplace_back("Use 7MHz for A500 or 14MHz for A1200 speed. Fastest uses more emulation time");
-	helptext.emplace_back("for the CPU, and Turbo will give only the minimum time to the Chipset, using as");
-	helptext.emplace_back("much as possible for the CPU, usually resulting in dropping frames also.");
+	helptext.emplace_back("Use 7MHz for A500 or 14MHz for A1200 speed. Fastest Possible will give only the minimum time");
+	helptext.emplace_back("to the Chipset, using as much as possible for the CPU, which might result in dropping");
+	helptext.emplace_back("frames also.");
+	helptext.emplace_back(" ");
+	helptext.emplace_back("You can use the CPU Idle slider to set how much the CPU emulation should sleep when idle.");
+	helptext.emplace_back("This is useful to keep the system temperature down.");
 	helptext.emplace_back(" ");
 	helptext.emplace_back("In current version, you will not see a difference in the performance for 68020,");
 	helptext.emplace_back("68030 and 68040 CPUs. The CPU cycles for the opcodes are based on 68020. The different");
diff --git a/src/osdep/gui/PanelRAM.cpp b/src/osdep/gui/PanelRAM.cpp
index 931d5984..cdc894dc 100644
--- a/src/osdep/gui/PanelRAM.cpp
+++ b/src/osdep/gui/PanelRAM.cpp
@@ -56,46 +56,46 @@ public:
 	{
 		if (actionEvent.getSource() == sldChipmem)
 		{
-			changed_prefs.chipmem_size = ChipMem_values[int(sldChipmem->getValue())];
+			changed_prefs.chipmem_size = ChipMem_values[static_cast<int>(sldChipmem->getValue())];
 			if ((changed_prefs.chipmem_size > 0x200000) && (changed_prefs.fastmem[0].size > 0))
 				changed_prefs.fastmem[0].size = 0;
 		}
 
 		if (actionEvent.getSource() == sldSlowmem)
 		{
-			changed_prefs.bogomem_size = SlowMem_values[int(sldSlowmem->getValue())];
+			changed_prefs.bogomem_size = SlowMem_values[static_cast<int>(sldSlowmem->getValue())];
 		}
 
 		if (actionEvent.getSource() == sldFastmem)
 		{
-			changed_prefs.fastmem[0].size = FastMem_values[int(sldFastmem->getValue())];
+			changed_prefs.fastmem[0].size = FastMem_values[static_cast<int>(sldFastmem->getValue())];
 			if (changed_prefs.fastmem[0].size > 0 && changed_prefs.chipmem_size > 0x200000)
 				changed_prefs.chipmem_size = 0x200000;
 		}
 
 		if (actionEvent.getSource() == sldZ3mem)
 		{
-			changed_prefs.z3fastmem[0].size = FastMem_values[int(sldZ3mem->getValue())];
+			changed_prefs.z3fastmem[0].size = FastMem_values[static_cast<int>(sldZ3mem->getValue())];
 			if (changed_prefs.z3fastmem[0].size > max_z3fastmem)
 				changed_prefs.z3fastmem[0].size = max_z3fastmem;
 		}
 
 		if (actionEvent.getSource() == sldGfxmem)
 		{
-			changed_prefs.rtgboards[0].rtgmem_size = FastMem_values[int(sldGfxmem->getValue())];
+			changed_prefs.rtgboards[0].rtgmem_size = FastMem_values[static_cast<int>(sldGfxmem->getValue())];
 			changed_prefs.rtgboards[0].rtgmem_type = GFXBOARD_UAE_Z3;
 		}
 
 		if (actionEvent.getSource() == sldA3000Lowmem)
 		{
-			changed_prefs.mbresmem_low_size = A3000LowMem_values[int(sldA3000Lowmem->getValue())];
+			changed_prefs.mbresmem_low_size = A3000LowMem_values[static_cast<int>(sldA3000Lowmem->getValue())];
 			if (currprefs.mbresmem_low_size != changed_prefs.mbresmem_low_size)
 				DisableResume();
 		}
 
 		if (actionEvent.getSource() == sldA3000Highmem)
 		{
-			changed_prefs.mbresmem_high_size = A3000HighMem_values[int(sldA3000Highmem->getValue())];
+			changed_prefs.mbresmem_high_size = A3000HighMem_values[static_cast<int>(sldA3000Highmem->getValue())];
 			if (currprefs.mbresmem_high_size != changed_prefs.mbresmem_high_size)
 				DisableResume();
 		}