summaryrefslogtreecommitdiffstatshomepage
path: root/src/mame/includes/kikikai.h
blob: cdbabb19dc739526d0bbd0d6c741b7f0c9c9c9c5 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
// license:BSD-3-Clause
// copyright-holders:Ernesto Corvi

#include "cpu/m6805/m68705.h"
#include "cpu/m6800/m6801.h"

#include "sound/2203intf.h"
#include "emupal.h"
#include "screen.h"

class kikikai_state : public driver_device
{
public:
	kikikai_state(const machine_config &mconfig, device_type type, const char *tag)
		: driver_device(mconfig, type, tag),
		m_maincpu(*this, "maincpu"),
		m_audiocpu(*this, "audiocpu"),
		m_screen(*this, "screen"),
		m_mcu_sharedram(*this, "mcu_sharedram"),
		m_mainram(*this, "mainram"),
		m_subcpu(*this, "sub"),
		m_mcu(*this, "mcu"),
		m_ymsnd(*this, "ymsnd"),
		m_gfxdecode(*this, "gfxdecode"),
		m_palette(*this, "palette")
	{
	}

	void base(machine_config &config);
	void kicknrun(machine_config &config);

protected:
	required_device<cpu_device>         m_maincpu;
	required_device<cpu_device>         m_audiocpu;
	required_device<screen_device>      m_screen;
	required_shared_ptr<u8> m_mcu_sharedram;

	u32 screen_update_kicknrun(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	u32 screen_update_kikikai(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);

	virtual void machine_start() override;
	virtual void machine_reset() override;

private:
	/* memory pointers */
	required_shared_ptr<u8> m_mainram;

	/* video-related */
	int      m_charbank;

	/* devices */
	optional_device<cpu_device>         m_subcpu;   // kicknrun / mexico86 only
	optional_device<cpu_device>         m_mcu;
	required_device<ym2203_device>      m_ymsnd;
	required_device<gfxdecode_device>   m_gfxdecode;
	required_device<palette_device>     m_palette;

	/* queue */
	//u8 m_queue[64];
	//int m_qfront;
	//int m_qstate;
	void kicknrun_sub_output_w(uint8_t data);
	virtual void main_f008_w(uint8_t data);

	void main_bankswitch_w(uint8_t data);
	uint8_t kiki_ym2203_r(offs_t offset);

	virtual INTERRUPT_GEN_MEMBER(kikikai_interrupt);

	void main_map(address_map &map);
	void sound_map(address_map &map);
	void kicknrun_sub_cpu_map(address_map &map);
	void mcu_map(address_map& map);

	/* Kiki KaiKai / Kick 'n Run MCU */
	uint8_t    m_ddr1;
	uint8_t    m_ddr2;
	uint8_t    m_ddr3;
	uint8_t    m_ddr4;
	uint8_t    m_port1_in;
	uint8_t    m_port2_in;
	uint8_t    m_port3_in;
	uint8_t    m_port4_in;
	uint8_t    m_port1_out;
	uint8_t    m_port2_out;
	uint8_t    m_port3_out;
	uint8_t    m_port4_out;

	uint8_t kikikai_mcu_ddr1_r();
	void kikikai_mcu_ddr1_w(uint8_t data);
	uint8_t kikikai_mcu_ddr2_r();
	void kikikai_mcu_ddr2_w(uint8_t data);
	uint8_t kikikai_mcu_ddr3_r();
	void kikikai_mcu_ddr3_w(uint8_t data);
	uint8_t kikikai_mcu_ddr4_r();
	void kikikai_mcu_ddr4_w(uint8_t data);
	uint8_t kikikai_mcu_port1_r();
	void kikikai_mcu_port1_w(uint8_t data);
	uint8_t kikikai_mcu_port2_r();
	void kikikai_mcu_port2_w(uint8_t data);
	uint8_t kikikai_mcu_port3_r();
	void kikikai_mcu_port3_w(uint8_t data);
	uint8_t kikikai_mcu_port4_r();
	void kikikai_mcu_port4_w(uint8_t data);
};

class mexico86_state : public kikikai_state
{
public:
	mexico86_state(const machine_config& mconfig, device_type type, const char* tag)
		: kikikai_state(mconfig, type, tag),
		m_68705mcu(*this, "68705mcu")
	{
	}

	void mexico86_68705(machine_config& config);
	void knightb(machine_config &config);

protected:
	virtual void machine_start() override;
	virtual void machine_reset() override;

private:
	virtual void main_f008_w(uint8_t data) override;

	INTERRUPT_GEN_MEMBER(mexico86_m68705_interrupt);
	void mexico86_68705_port_a_w(u8 data);
	void mexico86_68705_port_b_w(offs_t offset, u8 data, u8 mem_mask = ~0);

	optional_device<m68705p_device>     m_68705mcu;

	/* mcu */
	/* mexico86 68705 protection */
	u8       m_port_a_out;
	u8       m_port_b_out;
	int      m_address;
	u8       m_latch;

};

class kikikai_simulation_state : public kikikai_state
{
public:
	kikikai_simulation_state(const machine_config& mconfig, device_type type, const char* tag)
		: kikikai_state(mconfig, type, tag)
	{
	}

	void kikikai(machine_config& config);

protected:
	virtual void machine_start() override;
	virtual void machine_reset() override;

private:
	virtual void main_f008_w(uint8_t data) override;

	virtual INTERRUPT_GEN_MEMBER(kikikai_interrupt) override;

	void mcu_simulate(  );

	/* kikikai mcu simulation */
	int      m_kikikai_simulated_mcu_running;
	int      m_kikikai_simulated_mcu_initialised;
	bool     m_coin_last[2];
	u8       m_coin_fract;
};