コード例 #1
0
void cloud9_state::machine_start()
{
	rectangle visarea;

	/* initialize globals */
	m_syncprom = memregion("proms")->base() + 0x000;

	/* find the start of VBLANK in the SYNC PROM */
	for (m_vblank_start = 0; m_vblank_start < 256; m_vblank_start++)
		if ((m_syncprom[(m_vblank_start - 1) & 0xff] & 2) != 0 && (m_syncprom[m_vblank_start] & 2) == 0)
			break;
	if (m_vblank_start == 0)
		m_vblank_start = 256;

	/* find the end of VBLANK in the SYNC PROM */
	for (m_vblank_end = 0; m_vblank_end < 256; m_vblank_end++)
		if ((m_syncprom[(m_vblank_end - 1) & 0xff] & 2) == 0 && (m_syncprom[m_vblank_end] & 2) != 0)
			break;

	/* can't handle the wrapping case */
	assert(m_vblank_end < m_vblank_start);

	/* reconfigure the visible area to match */
	visarea.set(0, 255, m_vblank_end + 1, m_vblank_start);
	m_screen->configure(320, 256, visarea, HZ_TO_ATTOSECONDS(PIXEL_CLOCK) * VTOTAL * HTOTAL);

	/* create a timer for IRQs and set up the first callback */
	m_irq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(cloud9_state::clock_irq),this));
	m_irq_state = 0;
	schedule_next_irq(0-64);

	/* setup for save states */
	save_item(NAME(m_irq_state));
}
コード例 #2
0
ファイル: cloud9.c プロジェクト: broftkd/historic-mess
static void clock_irq(int param)
{
	/* assert the IRQ if not already asserted */
	if (!irq_state)
	{
		cpunum_set_input_line(0, 0, ASSERT_LINE);
		irq_state = 1;
	}

	/* force an update now */
	video_screen_update_partial(0, video_screen_get_vpos(0));

	/* find the next edge */
	schedule_next_irq(param);
}
コード例 #3
0
ファイル: cloud9.c プロジェクト: cdenix/ps3-mame-0125
static TIMER_CALLBACK( clock_irq )
{
    /* assert the IRQ if not already asserted */
    if (!irq_state)
    {
        cpunum_set_input_line(machine, 0, 0, ASSERT_LINE);
        irq_state = 1;
    }

    /* force an update now */
    video_screen_update_partial(machine->primary_screen, video_screen_get_vpos(machine->primary_screen));

    /* find the next edge */
    schedule_next_irq(machine, param);
}
コード例 #4
0
ファイル: cloud9.c プロジェクト: hstampfl/mame2010-libretro
static TIMER_CALLBACK( clock_irq )
{
	cloud9_state *state = (cloud9_state *)machine->driver_data;
	/* assert the IRQ if not already asserted */
	if (!state->irq_state)
	{
		cpu_set_input_line(state->maincpu, 0, ASSERT_LINE);
		state->irq_state = 1;
	}

	/* force an update now */
	machine->primary_screen->update_partial(machine->primary_screen->vpos());

	/* find the next edge */
	schedule_next_irq(machine, param);
}
コード例 #5
0
ファイル: ccastles.c プロジェクト: shangma/mame0112
static MACHINE_START( ccastles )
{
	rectangle visarea;

	/* initialize globals */
	syncprom = memory_region(REGION_PROMS) + 0x000;

	/* find the start of VBLANK in the SYNC PROM */
	for (ccastles_vblank_start = 0; ccastles_vblank_start < 256; ccastles_vblank_start++)
		if ((syncprom[(ccastles_vblank_start - 1) & 0xff] & 1) == 0 && (syncprom[ccastles_vblank_start] & 1) != 0)
			break;
	if (ccastles_vblank_start == 0)
		ccastles_vblank_start = 256;

	/* find the end of VBLANK in the SYNC PROM */
	for (ccastles_vblank_end = 0; ccastles_vblank_end < 256; ccastles_vblank_end++)
		if ((syncprom[(ccastles_vblank_end - 1) & 0xff] & 1) != 0 && (syncprom[ccastles_vblank_end] & 1) == 0)
			break;

	/* can't handle the wrapping case */
	assert(ccastles_vblank_end < ccastles_vblank_start);

	/* reconfigure the visible area to match */
	visarea.min_x = 0;
	visarea.max_x = 255;
	visarea.min_y = ccastles_vblank_end;
	visarea.max_y = ccastles_vblank_start - 1;
	video_screen_configure(0, 320, 256, &visarea, (float)PIXEL_CLOCK / (float)VTOTAL / (float)HTOTAL);

	/* configure the ROM banking */
	memory_configure_bank(1, 0, 2, memory_region(REGION_CPU1) + 0xa000, 0x6000);

	/* create a timer for IRQs and set up the first callback */
	irq_timer = timer_alloc(clock_irq);
	irq_state = 0;
	schedule_next_irq(0);

	/* allocate backing memory for the NVRAM */
	generic_nvram = auto_malloc(generic_nvram_size);

	/* setup for save states */
	state_save_register_global(irq_state);
	state_save_register_global_array(nvram_store);
	state_save_register_global_pointer(generic_nvram, generic_nvram_size);

	return 0;
}
コード例 #6
0
ファイル: ccastles.c プロジェクト: broftkd/mess-svn
static TIMER_CALLBACK( clock_irq )
{
	ccastles_state *state = machine.driver_data<ccastles_state>();

	/* assert the IRQ if not already asserted */
	if (!state->m_irq_state)
	{
		device_set_input_line(state->m_maincpu, 0, ASSERT_LINE);
		state->m_irq_state = 1;
	}

	/* force an update now */
	machine.primary_screen->update_partial(machine.primary_screen->vpos());

	/* find the next edge */
	schedule_next_irq(machine, param);
}
コード例 #7
0
ファイル: cloud9.c プロジェクト: hstampfl/mame2010-libretro
static MACHINE_START( cloud9 )
{
	cloud9_state *state = (cloud9_state *)machine->driver_data;
	rectangle visarea;

	/* initialize globals */
	state->maincpu = machine->device("maincpu");
	state->syncprom = memory_region(machine, "proms") + 0x000;

	/* find the start of VBLANK in the SYNC PROM */
	for (state->vblank_start = 0; state->vblank_start < 256; state->vblank_start++)
		if ((state->syncprom[(state->vblank_start - 1) & 0xff] & 2) != 0 && (state->syncprom[state->vblank_start] & 2) == 0)
			break;
	if (state->vblank_start == 0)
		state->vblank_start = 256;

	/* find the end of VBLANK in the SYNC PROM */
	for (state->vblank_end = 0; state->vblank_end < 256; state->vblank_end++)
		if ((state->syncprom[(state->vblank_end - 1) & 0xff] & 2) == 0 && (state->syncprom[state->vblank_end] & 2) != 0)
			break;

	/* can't handle the wrapping case */
	assert(state->vblank_end < state->vblank_start);

	/* reconfigure the visible area to match */
	visarea.min_x = 0;
	visarea.max_x = 255;
	visarea.min_y = state->vblank_end + 1;
	visarea.max_y = state->vblank_start;
	machine->primary_screen->configure(320, 256, visarea, HZ_TO_ATTOSECONDS(PIXEL_CLOCK) * VTOTAL * HTOTAL);

	/* create a timer for IRQs and set up the first callback */
	state->irq_timer = timer_alloc(machine, clock_irq, NULL);
	state->irq_state = 0;
	schedule_next_irq(machine, 0-64);

	/* allocate backing memory for the NVRAM */
	machine->generic.nvram.u8 = auto_alloc_array(machine, UINT8, machine->generic.nvram_size);

	/* setup for save states */
	state_save_register_global(machine, state->irq_state);
	state_save_register_global_pointer(machine, machine->generic.nvram.u8, machine->generic.nvram_size);
}
コード例 #8
0
ファイル: cloud9.c プロジェクト: cdenix/ps3-mame-0125
static MACHINE_START( cloud9 )
{
    rectangle visarea;

    /* initialize globals */
    syncprom = memory_region(REGION_PROMS) + 0x000;

    /* find the start of VBLANK in the SYNC PROM */
    for (cloud9_vblank_start = 0; cloud9_vblank_start < 256; cloud9_vblank_start++)
        if ((syncprom[(cloud9_vblank_start - 1) & 0xff] & 2) != 0 && (syncprom[cloud9_vblank_start] & 2) == 0)
            break;
    if (cloud9_vblank_start == 0)
        cloud9_vblank_start = 256;

    /* find the end of VBLANK in the SYNC PROM */
    for (cloud9_vblank_end = 0; cloud9_vblank_end < 256; cloud9_vblank_end++)
        if ((syncprom[(cloud9_vblank_end - 1) & 0xff] & 2) == 0 && (syncprom[cloud9_vblank_end] & 2) != 0)
            break;

    /* can't handle the wrapping case */
    assert(cloud9_vblank_end < cloud9_vblank_start);

    /* reconfigure the visible area to match */
    visarea.min_x = 0;
    visarea.max_x = 255;
    visarea.min_y = cloud9_vblank_end + 1;
    visarea.max_y = cloud9_vblank_start;
    video_screen_configure(machine->primary_screen, 320, 256, &visarea, HZ_TO_ATTOSECONDS(PIXEL_CLOCK) * VTOTAL * HTOTAL);

    /* create a timer for IRQs and set up the first callback */
    irq_timer = timer_alloc(clock_irq, NULL);
    irq_state = 0;
    schedule_next_irq(machine, 0-64);

    /* allocate backing memory for the NVRAM */
    generic_nvram = auto_malloc(generic_nvram_size);

    /* setup for save states */
    state_save_register_global(irq_state);
    state_save_register_global_pointer(generic_nvram, generic_nvram_size);
}
コード例 #9
0
ファイル: ccastles.c プロジェクト: broftkd/mess-svn
static MACHINE_START( ccastles )
{
	ccastles_state *state = machine.driver_data<ccastles_state>();
	rectangle visarea;

	/* initialize globals */
	state->m_syncprom = state->memregion("proms")->base() + 0x000;

	/* find the start of VBLANK in the SYNC PROM */
	for (state->m_vblank_start = 0; state->m_vblank_start < 256; state->m_vblank_start++)
		if ((state->m_syncprom[(state->m_vblank_start - 1) & 0xff] & 1) == 0 && (state->m_syncprom[state->m_vblank_start] & 1) != 0)
			break;
	if (state->m_vblank_start == 0)
		state->m_vblank_start = 256;

	/* find the end of VBLANK in the SYNC PROM */
	for (state->m_vblank_end = 0; state->m_vblank_end < 256; state->m_vblank_end++)
		if ((state->m_syncprom[(state->m_vblank_end - 1) & 0xff] & 1) != 0 && (state->m_syncprom[state->m_vblank_end] & 1) == 0)
			break;

	/* can't handle the wrapping case */
	assert(state->m_vblank_end < state->m_vblank_start);

	/* reconfigure the visible area to match */
	visarea.set(0, 255, state->m_vblank_end, state->m_vblank_start - 1);
	machine.primary_screen->configure(320, 256, visarea, HZ_TO_ATTOSECONDS(PIXEL_CLOCK) * VTOTAL * HTOTAL);

	/* configure the ROM banking */
	state->membank("bank1")->configure_entries(0, 2, state->memregion("maincpu")->base() + 0xa000, 0x6000);

	/* create a timer for IRQs and set up the first callback */
	state->m_irq_timer = machine.scheduler().timer_alloc(FUNC(clock_irq));
	state->m_irq_state = 0;
	schedule_next_irq(machine, 0);

	/* setup for save states */
	state->save_item(NAME(state->m_irq_state));
	state->save_item(NAME(state->m_nvram_store));
}