[picodrive.git] / pico / pico_cmn.c

/*
 * common code for base/cd/32x
 * (C) notaz, 2007-2009,2013
 *
 * This work is licensed under the terms of MAME license.
 * See COPYING file in the top-level directory.
 */

#define CYCLES_M68K_LINE     488 // suitable for both PAL/NTSC
#define CYCLES_M68K_VINT_LAG  68

// pad delay (for 6 button pads)
#define PAD_DELAY() { \
  if(Pico.m.padDelay[0]++ > 25) Pico.m.padTHPhase[0]=0; \
  if(Pico.m.padDelay[1]++ > 25) Pico.m.padTHPhase[1]=0; \
}

// CPUS_RUN
#ifndef CPUS_RUN
#define CPUS_RUN(m68k_cycles) \
  SekRunM68k(m68k_cycles)
#endif

// sync m68k to SekCycleAim
static void SekSyncM68k(void)
{
  int cyc_do;
  pprof_start(m68k);
  pevt_log_m68k_o(EVT_RUN_START);

  while ((cyc_do = SekCycleAim - SekCycleCnt) > 0) {
    SekCycleCnt += cyc_do;

#if defined(EMU_C68K)
    PicoCpuCM68k.cycles = cyc_do;
    CycloneRun(&PicoCpuCM68k);
    SekCycleCnt -= PicoCpuCM68k.cycles;
#elif defined(EMU_M68K)
    SekCycleCnt += m68k_execute(cyc_do) - cyc_do;
#elif defined(EMU_F68K)
    SekCycleCnt += fm68k_emulate(cyc_do, 0) - cyc_do;
#endif
  }

  SekCyclesLeft = 0;

  SekTrace(0);
  pevt_log_m68k_o(EVT_RUN_END);
  pprof_end(m68k);
}

static inline void SekRunM68k(int cyc)
{
  SekCycleAim += cyc;
  cyc = SekCycleAim - SekCycleCnt;
  if (cyc <= 0)
    return;
  SekCycleCnt += cyc >> 6; // refresh slowdowns
  SekSyncM68k();
}

static void do_hint(struct PicoVideo *pv)
{
  pv->pending_ints |= 0x10;
  if (pv->reg[0] & 0x10) {
    elprintf(EL_INTS, "hint: @ %06x [%u]", SekPc, SekCyclesDone());
    SekInterrupt(4);
  }
}

static void do_timing_hacks_as(struct PicoVideo *pv, int vdp_slots)
{
  pv->lwrite_cnt += vdp_slots - Pico.m.dma_xfers * 2; // wrong *2
  if (pv->lwrite_cnt > vdp_slots)
    pv->lwrite_cnt = vdp_slots;
  else if (pv->lwrite_cnt < 0)
    pv->lwrite_cnt = 0;
  if (Pico.m.dma_xfers)
    SekCyclesBurn(CheckDMA());
}

static void do_timing_hacks_vb(void)
{
  if (Pico.m.dma_xfers)
    SekCyclesBurn(CheckDMA());
}

static int PicoFrameHints(void)
{
  struct PicoVideo *pv = &Pico.video;
  int line_sample = Pico.m.pal ? 68 : 93;
  int vdp_slots = (Pico.video.reg[12] & 1) ? 18 : 16;
  int lines, y, lines_vis, skip;
  int vcnt_wrap, vcnt_adj;
  unsigned int cycles;
  int hint; // Hint counter

  pevt_log_m68k_o(EVT_FRAME_START);

  if ((PicoOpt&POPT_ALT_RENDERER) && !PicoSkipFrame && (pv->reg[1]&0x40)) { // fast rend., display enabled
    // draw a frame just after vblank in alternative render mode
    // yes, this will cause 1 frame lag, but this is inaccurate mode anyway.
    PicoFrameFull();
#ifdef DRAW_FINISH_FUNC
    DRAW_FINISH_FUNC();
#endif
    skip = 1;
  }
  else skip=PicoSkipFrame;

  timing.m68c_frame_start = SekCyclesDone();
  pv->v_counter = Pico.m.scanline = 0;
  z80_resetCycles();
  PsndStartFrame();

  // Load H-Int counter
  hint = (pv->status & PVS_ACTIVE) ? pv->hint_cnt : pv->reg[10];

  pv->status |= PVS_ACTIVE;

  for (y = 0; ; y++)
  {
    pv->v_counter = Pico.m.scanline = y;
    if ((pv->reg[12]&6) == 6) { // interlace mode 2
      pv->v_counter <<= 1;
      pv->v_counter |= pv->v_counter >> 8;
      pv->v_counter &= 0xff;
    }

    if ((y == 224 && !(pv->reg[1] & 8)) || y == 240)
      break;

    PAD_DELAY();

    // H-Interrupts:
    if (--hint < 0)
    {
      hint = pv->reg[10]; // Reload H-Int counter
      do_hint(pv);
    }

    // decide if we draw this line
    if (!skip && (PicoOpt & POPT_ALT_RENDERER))
    {
      // find the right moment for frame renderer, when display is no longer blanked
      if ((pv->reg[1]&0x40) || y > 100) {
        PicoFrameFull();
#ifdef DRAW_FINISH_FUNC
        DRAW_FINISH_FUNC();
#endif
        skip = 1;
      }
    }

    // get samples from sound chips
    if ((y == 224 || y == line_sample) && PsndOut)
    {
      cycles = SekCyclesDone();

      if (Pico.m.z80Run && !Pico.m.z80_reset && (PicoOpt&POPT_EN_Z80))
        PicoSyncZ80(cycles);
#ifdef PICO_CD
      if (PicoAHW & PAHW_MCD)
        pcd_sync_s68k(cycles, 0);
#endif
#ifdef PICO_32X
      p32x_sync_sh2s(cycles);
#endif
      PsndGetSamples(y);
    }

    // Run scanline:
    line_base_cycles = SekCyclesDone();
    do_timing_hacks_as(pv, vdp_slots);
    CPUS_RUN(CYCLES_M68K_LINE);

    if (PicoLineHook) PicoLineHook();
    pevt_log_m68k_o(EVT_NEXT_LINE);
  }

  lines_vis = (pv->reg[1] & 8) ? 240 : 224;
  if (y == lines_vis)
    pv->status &= ~PVS_ACTIVE;

  if (!skip)
  {
    if (Pico.est.DrawScanline < y)
      PicoDrawSync(y - 1, 0);
#ifdef DRAW_FINISH_FUNC
    DRAW_FINISH_FUNC();
#endif
  }

  // VDP FIFO
  pv->lwrite_cnt = 0;
  Pico.video.status |= SR_EMPT;

  memcpy(PicoPadInt, PicoPad, sizeof(PicoPadInt));
  PAD_DELAY();

  // Last H-Int (normally):
  if (--hint < 0)
  {
    hint = pv->reg[10]; // Reload H-Int counter
    do_hint(pv);
  }

  pv->status |= SR_VB; // go into vblank
  pv->pending_ints |= 0x20;

  // the following SekRun is there for several reasons:
  // there must be a delay after vblank bit is set and irq is asserted (Mazin Saga)
  // also delay between F bit (bit 7) is set in SR and IRQ happens (Ex-Mutants)
  // also delay between last H-int and V-int (Golden Axe 3)
  line_base_cycles = SekCyclesDone();
  do_timing_hacks_vb();
  CPUS_RUN(CYCLES_M68K_VINT_LAG);

  if (pv->reg[1] & 0x20) {
    elprintf(EL_INTS, "vint: @ %06x [%u]", SekPc, SekCyclesDone());
    SekInterrupt(6);
  }

  cycles = SekCyclesDone();
  if (Pico.m.z80Run && !Pico.m.z80_reset && (PicoOpt&POPT_EN_Z80)) {
    PicoSyncZ80(cycles);
    elprintf(EL_INTS, "zint");
    z80_int();
  }

#ifdef PICO_CD
  if (PicoAHW & PAHW_MCD)
    pcd_sync_s68k(cycles, 0);
#endif
#ifdef PICO_32X
  p32x_sync_sh2s(cycles);
  p32x_start_blank();
#endif

  // get samples from sound chips
  if (y == 224 && PsndOut)
    PsndGetSamples(y);

  // Run scanline:
  CPUS_RUN(CYCLES_M68K_LINE - CYCLES_M68K_VINT_LAG);

  if (PicoLineHook) PicoLineHook();
  pevt_log_m68k_o(EVT_NEXT_LINE);

  if (Pico.m.pal) {
    lines = 313;
    vcnt_wrap = 0x103;
    vcnt_adj = 57;
  }
  else {
    lines = 262;
    vcnt_wrap = 0xEB;
    vcnt_adj = 6;
  }

  for (y++; y < lines - 1; y++)
  {
    pv->v_counter = Pico.m.scanline = y;
    if (y >= vcnt_wrap)
      pv->v_counter -= vcnt_adj;
    if ((pv->reg[12]&6) == 6)
      pv->v_counter = (pv->v_counter << 1) | 1;
    pv->v_counter &= 0xff;

    PAD_DELAY();

    if ((pv->status & PVS_ACTIVE) && --hint < 0)
    {
      hint = pv->reg[10]; // Reload H-Int counter
      do_hint(pv);
    }

    // Run scanline:
    line_base_cycles = SekCyclesDone();
    do_timing_hacks_vb();
    CPUS_RUN(CYCLES_M68K_LINE);

    if (PicoLineHook) PicoLineHook();
    pevt_log_m68k_o(EVT_NEXT_LINE);
  }

  pv->status &= ~SR_VB;

  // last scanline
  Pico.m.scanline = y;
  pv->v_counter = 0xff;
  pv->lwrite_cnt = 0;

  PAD_DELAY();

  if ((pv->status & PVS_ACTIVE) && --hint < 0)
  {
    hint = pv->reg[10]; // Reload H-Int counter
    do_hint(pv);
  }

  // Run scanline:
  line_base_cycles = SekCyclesDone();
  do_timing_hacks_as(pv, vdp_slots);
  CPUS_RUN(CYCLES_M68K_LINE);

  if (PicoLineHook) PicoLineHook();
  pevt_log_m68k_o(EVT_NEXT_LINE);

  // sync cpus
  cycles = SekCyclesDone();
  if (Pico.m.z80Run && !Pico.m.z80_reset && (PicoOpt&POPT_EN_Z80))
    PicoSyncZ80(cycles);
  if (PsndOut && ym2612.dacen && PsndDacLine < lines)
    PsndDoDAC(lines - 1);
  if (PsndOut && PsndPsgLine < lines)
    PsndDoPSG(lines - 1);

#ifdef PICO_CD
  if (PicoAHW & PAHW_MCD)
    pcd_sync_s68k(cycles, 0);
#endif
#ifdef PICO_32X
  p32x_sync_sh2s(cycles);
#endif
  timers_cycle();

  pv->hint_cnt = hint;

  return 0;
}

#undef PAD_DELAY
#undef CPUS_RUN

// vim:shiftwidth=2:ts=2:expandtab
Commit	Line	Data
	1	/*
	2	* common code for base/cd/32x
	3	* (C) notaz, 2007-2009,2013
	4	*
	5	* This work is licensed under the terms of MAME license.
	6	* See COPYING file in the top-level directory.
	7	*/
	8
	9	#define CYCLES_M68K_LINE 488 // suitable for both PAL/NTSC
	10	#define CYCLES_M68K_VINT_LAG 68
	11
	12	// pad delay (for 6 button pads)
	13	#define PAD_DELAY() { \
	14	if(Pico.m.padDelay[0]++ > 25) Pico.m.padTHPhase[0]=0; \
	15	if(Pico.m.padDelay[1]++ > 25) Pico.m.padTHPhase[1]=0; \
	16	}
	17
	18	// CPUS_RUN
	19	#ifndef CPUS_RUN
	20	#define CPUS_RUN(m68k_cycles) \
	21	SekRunM68k(m68k_cycles)
	22	#endif
	23
	24	// sync m68k to SekCycleAim
	25	static void SekSyncM68k(void)
	26	{
	27	int cyc_do;
	28	pprof_start(m68k);
	29	pevt_log_m68k_o(EVT_RUN_START);
	30
	31	while ((cyc_do = SekCycleAim - SekCycleCnt) > 0) {
	32	SekCycleCnt += cyc_do;
	33
	34	#if defined(EMU_C68K)
	35	PicoCpuCM68k.cycles = cyc_do;
	36	CycloneRun(&PicoCpuCM68k);
	37	SekCycleCnt -= PicoCpuCM68k.cycles;
	38	#elif defined(EMU_M68K)
	39	SekCycleCnt += m68k_execute(cyc_do) - cyc_do;
	40	#elif defined(EMU_F68K)
	41	SekCycleCnt += fm68k_emulate(cyc_do, 0) - cyc_do;
	42	#endif
	43	}
	44
	45	SekCyclesLeft = 0;
	46
	47	SekTrace(0);
	48	pevt_log_m68k_o(EVT_RUN_END);
	49	pprof_end(m68k);
	50	}
	51
	52	static inline void SekRunM68k(int cyc)
	53	{
	54	SekCycleAim += cyc;
	55	cyc = SekCycleAim - SekCycleCnt;
	56	if (cyc <= 0)
	57	return;
	58	SekCycleCnt += cyc >> 6; // refresh slowdowns
	59	SekSyncM68k();
	60	}
	61
	62	static void do_hint(struct PicoVideo *pv)
	63	{
	64	pv->pending_ints \|= 0x10;
	65	if (pv->reg[0] & 0x10) {
	66	elprintf(EL_INTS, "hint: @ %06x [%u]", SekPc, SekCyclesDone());
	67	SekInterrupt(4);
	68	}
	69	}
	70
	71	static void do_timing_hacks_as(struct PicoVideo *pv, int vdp_slots)
	72	{
	73	pv->lwrite_cnt += vdp_slots - Pico.m.dma_xfers * 2; // wrong *2
	74	if (pv->lwrite_cnt > vdp_slots)
	75	pv->lwrite_cnt = vdp_slots;
	76	else if (pv->lwrite_cnt < 0)
	77	pv->lwrite_cnt = 0;
	78	if (Pico.m.dma_xfers)
	79	SekCyclesBurn(CheckDMA());
	80	}
	81
	82	static void do_timing_hacks_vb(void)
	83	{
	84	if (Pico.m.dma_xfers)
	85	SekCyclesBurn(CheckDMA());
	86	}
	87
	88	static int PicoFrameHints(void)
	89	{
	90	struct PicoVideo *pv = &Pico.video;
	91	int line_sample = Pico.m.pal ? 68 : 93;
	92	int vdp_slots = (Pico.video.reg[12] & 1) ? 18 : 16;
	93	int lines, y, lines_vis, skip;
	94	int vcnt_wrap, vcnt_adj;
	95	unsigned int cycles;
	96	int hint; // Hint counter
	97
	98	pevt_log_m68k_o(EVT_FRAME_START);
	99
	100	if ((PicoOpt&POPT_ALT_RENDERER) && !PicoSkipFrame && (pv->reg[1]&0x40)) { // fast rend., display enabled
	101	// draw a frame just after vblank in alternative render mode
	102	// yes, this will cause 1 frame lag, but this is inaccurate mode anyway.
	103	PicoFrameFull();
	104	#ifdef DRAW_FINISH_FUNC
	105	DRAW_FINISH_FUNC();
	106	#endif
	107	skip = 1;
	108	}
	109	else skip=PicoSkipFrame;
	110
	111	timing.m68c_frame_start = SekCyclesDone();
	112	pv->v_counter = Pico.m.scanline = 0;
	113	z80_resetCycles();
	114	PsndStartFrame();
	115
	116	// Load H-Int counter
	117	hint = (pv->status & PVS_ACTIVE) ? pv->hint_cnt : pv->reg[10];
	118
	119	pv->status \|= PVS_ACTIVE;
	120
	121	for (y = 0; ; y++)
	122	{
	123	pv->v_counter = Pico.m.scanline = y;
	124	if ((pv->reg[12]&6) == 6) { // interlace mode 2
	125	pv->v_counter <<= 1;
	126	pv->v_counter \|= pv->v_counter >> 8;
	127	pv->v_counter &= 0xff;
	128	}
	129
	130	if ((y == 224 && !(pv->reg[1] & 8)) \|\| y == 240)
	131	break;
	132
	133	PAD_DELAY();
	134
	135	// H-Interrupts:
	136	if (--hint < 0)
	137	{
	138	hint = pv->reg[10]; // Reload H-Int counter
	139	do_hint(pv);
	140	}
	141
	142	// decide if we draw this line
	143	if (!skip && (PicoOpt & POPT_ALT_RENDERER))
	144	{
	145	// find the right moment for frame renderer, when display is no longer blanked
	146	if ((pv->reg[1]&0x40) \|\| y > 100) {
	147	PicoFrameFull();
	148	#ifdef DRAW_FINISH_FUNC
	149	DRAW_FINISH_FUNC();
	150	#endif
	151	skip = 1;
	152	}
	153	}
	154
	155	// get samples from sound chips
	156	if ((y == 224 \|\| y == line_sample) && PsndOut)
	157	{
	158	cycles = SekCyclesDone();
	159
	160	if (Pico.m.z80Run && !Pico.m.z80_reset && (PicoOpt&POPT_EN_Z80))
	161	PicoSyncZ80(cycles);
	162	#ifdef PICO_CD
	163	if (PicoAHW & PAHW_MCD)
	164	pcd_sync_s68k(cycles, 0);
	165	#endif
	166	#ifdef PICO_32X
	167	p32x_sync_sh2s(cycles);
	168	#endif
	169	PsndGetSamples(y);
	170	}
	171
	172	// Run scanline:
	173	line_base_cycles = SekCyclesDone();
	174	do_timing_hacks_as(pv, vdp_slots);
	175	CPUS_RUN(CYCLES_M68K_LINE);
	176
	177	if (PicoLineHook) PicoLineHook();
	178	pevt_log_m68k_o(EVT_NEXT_LINE);
	179	}
	180
	181	lines_vis = (pv->reg[1] & 8) ? 240 : 224;
	182	if (y == lines_vis)
	183	pv->status &= ~PVS_ACTIVE;
	184
	185	if (!skip)
	186	{
	187	if (Pico.est.DrawScanline < y)
	188	PicoDrawSync(y - 1, 0);
	189	#ifdef DRAW_FINISH_FUNC
	190	DRAW_FINISH_FUNC();
	191	#endif
	192	}
	193
	194	// VDP FIFO
	195	pv->lwrite_cnt = 0;
	196	Pico.video.status \|= SR_EMPT;
	197
	198	memcpy(PicoPadInt, PicoPad, sizeof(PicoPadInt));
	199	PAD_DELAY();
	200
	201	// Last H-Int (normally):
	202	if (--hint < 0)
	203	{
	204	hint = pv->reg[10]; // Reload H-Int counter
	205	do_hint(pv);
	206	}
	207
	208	pv->status \|= SR_VB; // go into vblank
	209	pv->pending_ints \|= 0x20;
	210
	211	// the following SekRun is there for several reasons:
	212	// there must be a delay after vblank bit is set and irq is asserted (Mazin Saga)
	213	// also delay between F bit (bit 7) is set in SR and IRQ happens (Ex-Mutants)
	214	// also delay between last H-int and V-int (Golden Axe 3)
	215	line_base_cycles = SekCyclesDone();
	216	do_timing_hacks_vb();
	217	CPUS_RUN(CYCLES_M68K_VINT_LAG);
	218
	219	if (pv->reg[1] & 0x20) {
	220	elprintf(EL_INTS, "vint: @ %06x [%u]", SekPc, SekCyclesDone());
	221	SekInterrupt(6);
	222	}
	223
	224	cycles = SekCyclesDone();
	225	if (Pico.m.z80Run && !Pico.m.z80_reset && (PicoOpt&POPT_EN_Z80)) {
	226	PicoSyncZ80(cycles);
	227	elprintf(EL_INTS, "zint");
	228	z80_int();
	229	}
	230
	231	#ifdef PICO_CD
	232	if (PicoAHW & PAHW_MCD)
	233	pcd_sync_s68k(cycles, 0);
	234	#endif
	235	#ifdef PICO_32X
	236	p32x_sync_sh2s(cycles);
	237	p32x_start_blank();
	238	#endif
	239
	240	// get samples from sound chips
	241	if (y == 224 && PsndOut)
	242	PsndGetSamples(y);
	243
	244	// Run scanline:
	245	CPUS_RUN(CYCLES_M68K_LINE - CYCLES_M68K_VINT_LAG);
	246
	247	if (PicoLineHook) PicoLineHook();
	248	pevt_log_m68k_o(EVT_NEXT_LINE);
	249
	250	if (Pico.m.pal) {
	251	lines = 313;
	252	vcnt_wrap = 0x103;
	253	vcnt_adj = 57;
	254	}
	255	else {
	256	lines = 262;
	257	vcnt_wrap = 0xEB;
	258	vcnt_adj = 6;
	259	}
	260
	261	for (y++; y < lines - 1; y++)
	262	{
	263	pv->v_counter = Pico.m.scanline = y;
	264	if (y >= vcnt_wrap)
	265	pv->v_counter -= vcnt_adj;
	266	if ((pv->reg[12]&6) == 6)
	267	pv->v_counter = (pv->v_counter << 1) \| 1;
	268	pv->v_counter &= 0xff;
	269
	270	PAD_DELAY();
	271
	272	if ((pv->status & PVS_ACTIVE) && --hint < 0)
	273	{
	274	hint = pv->reg[10]; // Reload H-Int counter
	275	do_hint(pv);
	276	}
	277
	278	// Run scanline:
	279	line_base_cycles = SekCyclesDone();
	280	do_timing_hacks_vb();
	281	CPUS_RUN(CYCLES_M68K_LINE);
	282
	283	if (PicoLineHook) PicoLineHook();
	284	pevt_log_m68k_o(EVT_NEXT_LINE);
	285	}
	286
	287	pv->status &= ~SR_VB;
	288
	289	// last scanline
	290	Pico.m.scanline = y;
	291	pv->v_counter = 0xff;
	292	pv->lwrite_cnt = 0;
	293
	294	PAD_DELAY();
	295
	296	if ((pv->status & PVS_ACTIVE) && --hint < 0)
	297	{
	298	hint = pv->reg[10]; // Reload H-Int counter
	299	do_hint(pv);
	300	}
	301
	302	// Run scanline:
	303	line_base_cycles = SekCyclesDone();
	304	do_timing_hacks_as(pv, vdp_slots);
	305	CPUS_RUN(CYCLES_M68K_LINE);
	306
	307	if (PicoLineHook) PicoLineHook();
	308	pevt_log_m68k_o(EVT_NEXT_LINE);
	309
	310	// sync cpus
	311	cycles = SekCyclesDone();
	312	if (Pico.m.z80Run && !Pico.m.z80_reset && (PicoOpt&POPT_EN_Z80))
	313	PicoSyncZ80(cycles);
	314	if (PsndOut && ym2612.dacen && PsndDacLine < lines)
	315	PsndDoDAC(lines - 1);
	316	if (PsndOut && PsndPsgLine < lines)
	317	PsndDoPSG(lines - 1);
	318
	319	#ifdef PICO_CD
	320	if (PicoAHW & PAHW_MCD)
	321	pcd_sync_s68k(cycles, 0);
	322	#endif
	323	#ifdef PICO_32X
	324	p32x_sync_sh2s(cycles);
	325	#endif
	326	timers_cycle();
	327
	328	pv->hint_cnt = hint;
	329
	330	return 0;
	331	}
	332
	333	#undef PAD_DELAY
	334	#undef CPUS_RUN
	335
	336	// vim:shiftwidth=2:ts=2:expandtab