1 // license:BSD-3-Clause
2 // copyright-holders:AJR
3 /**********************************************************************
4
5 Rockwell R65C19 Microcomputer (MCU)
6
7 TODO: fully describe this MCU and its successors (C29, C39) and
8 emulate their internal peripherals (only core emulation now)
9
10 **********************************************************************/
11
12 #include "emu.h"
13 #include "r65c19.h"
14 #include "r65c19d.h"
15
16 DEFINE_DEVICE_TYPE(R65C19, r65c19_device, "r65c19", "Rockwell R65C19 MCU")
17 DEFINE_DEVICE_TYPE(L2800, l2800_device, "l2800", "Rockwell L2800 MCU")
18
r65c19_device(const machine_config & mconfig,device_type type,const char * tag,device_t * owner,u32 clock,address_map_constructor internal_map)19 r65c19_device::r65c19_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor internal_map)
20 : r65c02_device(mconfig, type, tag, owner, clock)
21 , m_w(0)
22 , m_i(0)
23 , m_page1_ram(*this, "page1")
24 , m_cir(0)
25 {
26 program_config.m_internal_map = std::move(internal_map);
27 }
28
r65c19_device(const machine_config & mconfig,const char * tag,device_t * owner,u32 clock)29 r65c19_device::r65c19_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
30 : r65c19_device(mconfig, R65C19, tag, owner, clock, address_map_constructor())
31 {
32 }
33
c39_device(const machine_config & mconfig,device_type type,const char * tag,device_t * owner,u32 clock,address_map_constructor internal_map)34 c39_device::c39_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor internal_map)
35 : r65c19_device(mconfig, type, tag, owner, clock, internal_map)
36 , m_exp_config("expansion", ENDIANNESS_LITTLE, 8, 21, 0)
37 , m_es4_config("ES4", ENDIANNESS_LITTLE, 8, 9, 0)
38 {
39 }
40
l2800_device(const machine_config & mconfig,const char * tag,device_t * owner,u32 clock)41 l2800_device::l2800_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
42 : c39_device(mconfig, L2800, tag, owner, clock, address_map_constructor(FUNC(l2800_device::internal_map), this))
43 {
44 }
45
create_disassembler()46 std::unique_ptr<util::disasm_interface> r65c19_device::create_disassembler()
47 {
48 return std::make_unique<r65c19_disassembler>();
49 }
50
do_add(u8 v)51 void r65c19_device::do_add(u8 v)
52 {
53 P &= ~F_C;
54 do_adc(v);
55 }
56
do_accumulate(u16 v,u16 w)57 u16 r65c19_device::do_accumulate(u16 v, u16 w)
58 {
59 // Compute the sum
60 s32 result = s16(v) + s16(w);
61
62 // Determine flags and saturate result upon overflow
63 P &= ~(F_N | F_V);
64 if (result > 32767)
65 {
66 P |= F_V;
67 result = 32767;
68 }
69 else if (result < 0)
70 {
71 P |= F_N;
72 if (result < -32768)
73 {
74 P |= F_V;
75 result = -32768;
76 }
77 }
78
79 // MPA and MPY always destroy the old value of Y, as does RND when it overflows
80 Y = result & 0xff;
81
82 // 16-bit result to W, or high byte to A
83 return result & 0xffff;
84 }
85
get_irq_vector()86 u16 r65c19_device::get_irq_vector()
87 {
88 // TODO: this is a stub
89 return 0xfffc;
90 }
91
device_start()92 void r65c19_device::device_start()
93 {
94 mintf = std::make_unique<mi_default>();
95
96 c19_init();
97 }
98
memory_space_config() const99 device_memory_interface::space_config_vector c39_device::memory_space_config() const
100 {
101 return space_config_vector {
102 std::make_pair(AS_PROGRAM, &program_config),
103 std::make_pair(AS_DATA, &m_exp_config),
104 std::make_pair(AS_IO, &m_es4_config)
105 };
106 }
107
device_start()108 void c39_device::device_start()
109 {
110 std::unique_ptr<mi_banked> intf = std::make_unique<mi_banked>();
111 space(AS_DATA).cache(intf->escache);
112 space(AS_DATA).specific(intf->exp);
113 space(AS_IO).specific(intf->es4);
114
115 save_item(NAME(intf->bsr));
116 save_item(NAME(intf->pbs));
117 mintf = std::move(intf);
118
119 c19_init();
120
121 for (int i = 0; i < 8; i++)
122 state_add(C39_BSR0 + i, string_format("BSR%d", i).c_str(), downcast<mi_banked &>(*mintf).bsr[i]);
123 }
124
c19_init()125 void r65c19_device::c19_init()
126 {
127 init();
128
129 state_add(R65C19_W, "W", m_w);
130 state_add<u8>(R65C19_WL, "WL",
131 [this]() { return m_w & 0xff; },
132 [this](u8 data) { m_w = set_l(m_w, data); }).noshow();
133 state_add<u8>(R65C19_WH, "WH",
134 [this]() { return m_w >> 8; },
135 [this](u8 data) { m_w = set_h(m_w, data); }).noshow();
136 state_add(R65C19_I, "I", m_i);
137
138 save_item(NAME(m_w));
139 save_item(NAME(m_i));
140 save_item(NAME(m_cir));
141 }
142
device_reset()143 void r65c19_device::device_reset()
144 {
145 r65c02_device::device_reset();
146
147 m_cir = 0x00;
148 }
149
device_reset()150 void c39_device::device_reset()
151 {
152 r65c02_device::device_reset();
153
154 mi_banked &intf = downcast<mi_banked &>(*mintf);
155 intf.bsr[0] = 0xe0;
156 intf.bsr[1] = 0xd1;
157 intf.bsr[2] = 0xb2;
158 intf.bsr[3] = 0xb3;
159 intf.bsr[4] = 0x74;
160 intf.bsr[5] = 0x75;
161 intf.bsr[6] = 0x76;
162 intf.bsr[7] = 0x77;
163 intf.pbs = 0xff;
164 }
165
page1_seg_r(offs_t offset)166 u8 r65c19_device::page1_seg_r(offs_t offset)
167 {
168 return m_page1_ram[(m_cir & 0x03) << 6 | offset];
169 }
170
page1_seg_w(offs_t offset,u8 data)171 void r65c19_device::page1_seg_w(offs_t offset, u8 data)
172 {
173 m_page1_ram[(m_cir & 0x03) << 6 | offset] = data;
174 }
175
cir_r()176 u8 r65c19_device::cir_r()
177 {
178 return m_cir;
179 }
180
cir_w(u8 data)181 void r65c19_device::cir_w(u8 data)
182 {
183 // TODO: clear interrupts
184 m_cir = data & 0x07;
185 }
186
exp_read(u16 adr)187 u8 c39_device::mi_banked::exp_read(u16 adr)
188 {
189 return exp.read_byte(u32(bsr[(adr & 0xe000) >> 13]) << 13 | (adr & 0x1fff));
190 }
191
exp_read_cached(u16 adr)192 u8 c39_device::mi_banked::exp_read_cached(u16 adr)
193 {
194 return escache.read_byte(u32(bsr[(adr & 0xe000) >> 13]) << 13 | (adr & 0x1fff));
195 }
196
exp_write(u16 adr,u8 val)197 void c39_device::mi_banked::exp_write(u16 adr, u8 val)
198 {
199 exp.write_byte(u32(bsr[(adr & 0xe000) >> 13]) << 13 | (adr & 0x1fff), val);
200 }
201
es4_read(u16 adr)202 u8 c39_device::mi_banked::es4_read(u16 adr)
203 {
204 return es4.read_byte(adr & 0x1ff);
205 }
206
es4_write(u16 adr,u8 val)207 void c39_device::mi_banked::es4_write(u16 adr, u8 val)
208 {
209 es4.write_byte(adr & 0x1ff, val);
210 }
211
read(u16 adr)212 u8 c39_device::mi_banked::read(u16 adr)
213 {
214 return program.read_byte(adr);
215 }
216
read_sync(u16 adr)217 u8 c39_device::mi_banked::read_sync(u16 adr)
218 {
219 if (adr < 0x0600)
220 return cprogram.read_byte(adr);
221 else if (adr >= 0x0800 || BIT(pbs, 1))
222 return exp_read_cached(adr);
223 else
224 return es4_read(adr);
225 }
226
read_arg(u16 adr)227 u8 c39_device::mi_banked::read_arg(u16 adr)
228 {
229 if (adr < 0x0600)
230 return cprogram.read_byte(adr);
231 else if (adr >= 0x0800 || BIT(pbs, 1))
232 return exp_read_cached(adr);
233 else
234 return es4_read(adr);
235 }
236
write(u16 adr,u8 val)237 void c39_device::mi_banked::write(u16 adr, u8 val)
238 {
239 program.write_byte(adr, val);
240 }
241
pbs_r()242 u8 c39_device::pbs_r()
243 {
244 return downcast<mi_banked &>(*mintf).pbs;
245 }
246
pbs_w(u8 data)247 void c39_device::pbs_w(u8 data)
248 {
249 downcast<mi_banked &>(*mintf).pbs = data;
250 }
251
bsr_r(offs_t offset)252 u8 c39_device::bsr_r(offs_t offset)
253 {
254 return downcast<mi_banked &>(*mintf).bsr[offset];
255 }
256
bsr_w(offs_t offset,u8 data)257 void c39_device::bsr_w(offs_t offset, u8 data)
258 {
259 downcast<mi_banked &>(*mintf).bsr[offset] = data;
260 }
261
expansion_r(offs_t offset)262 u8 c39_device::expansion_r(offs_t offset)
263 {
264 mi_banked &intf = downcast<mi_banked &>(*mintf);
265 if (offset >= 0x0200 || BIT(intf.pbs, 1))
266 return intf.exp_read(offset + 0x0600);
267 else
268 return intf.es4_read(offset + 0x0600);
269 }
270
expansion_w(offs_t offset,u8 data)271 void c39_device::expansion_w(offs_t offset, u8 data)
272 {
273 mi_banked &intf = downcast<mi_banked &>(*mintf);
274 if (offset >= 0x0200 || BIT(intf.pbs, 1))
275 intf.exp_write(offset + 0x0600, data);
276 else
277 intf.es4_write(offset + 0x0600, data);
278 }
279
internal_map(address_map & map)280 void l2800_device::internal_map(address_map &map)
281 {
282 // TODO: most registers still unimplemented
283 map(0x0005, 0x0005).rw(FUNC(l2800_device::pbs_r), FUNC(l2800_device::pbs_w));
284 map(0x000b, 0x000b).rw(FUNC(l2800_device::cir_r), FUNC(l2800_device::cir_w));
285 map(0x0018, 0x001f).rw(FUNC(l2800_device::bsr_r), FUNC(l2800_device::bsr_w));
286 map(0x0040, 0x05fd).ram(); // Page 0 has 192 dedicated bytes here
287 map(0x0600, 0xffff).rw(FUNC(l2800_device::expansion_r), FUNC(l2800_device::expansion_w));
288 }
289
290 #include "cpu/m6502/r65c19.hxx"
291