1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include "qemu/osdep.h"
22#include "qapi/error.h"
23#include "cpu.h"
24#include "qemu-common.h"
25#include "migration/vmstate.h"
26#include "exec/exec-all.h"
27
28
29static void m68k_cpu_set_pc(CPUState *cs, vaddr value)
30{
31 M68kCPU *cpu = M68K_CPU(cs);
32
33 cpu->env.pc = value;
34}
35
36static bool m68k_cpu_has_work(CPUState *cs)
37{
38 return cs->interrupt_request & CPU_INTERRUPT_HARD;
39}
40
41static void m68k_set_feature(CPUM68KState *env, int feature)
42{
43 env->features |= (1u << feature);
44}
45
46
47static void m68k_cpu_reset(CPUState *s)
48{
49 M68kCPU *cpu = M68K_CPU(s);
50 M68kCPUClass *mcc = M68K_CPU_GET_CLASS(cpu);
51 CPUM68KState *env = &cpu->env;
52 floatx80 nan = floatx80_default_nan(NULL);
53 int i;
54
55 mcc->parent_reset(s);
56
57 memset(env, 0, offsetof(CPUM68KState, end_reset_fields));
58#if !defined(CONFIG_USER_ONLY)
59 env->sr = 0x2700;
60#endif
61 m68k_switch_sp(env);
62 for (i = 0; i < 8; i++) {
63 env->fregs[i].d = nan;
64 }
65 cpu_m68k_set_fpcr(env, 0);
66 env->fpsr = 0;
67
68 cpu_m68k_set_ccr(env, 0);
69
70 env->pc = 0;
71}
72
73static void m68k_cpu_disas_set_info(CPUState *s, disassemble_info *info)
74{
75 M68kCPU *cpu = M68K_CPU(s);
76 CPUM68KState *env = &cpu->env;
77 info->print_insn = print_insn_m68k;
78 if (m68k_feature(env, M68K_FEATURE_M68000)) {
79 info->mach = bfd_mach_m68040;
80 }
81}
82
83
84
85static ObjectClass *m68k_cpu_class_by_name(const char *cpu_model)
86{
87 ObjectClass *oc;
88 char *typename;
89
90 if (cpu_model == NULL) {
91 return NULL;
92 }
93
94 typename = g_strdup_printf("%s-" TYPE_M68K_CPU, cpu_model);
95 oc = object_class_by_name(typename);
96 g_free(typename);
97 if (oc != NULL && (object_class_dynamic_cast(oc, TYPE_M68K_CPU) == NULL ||
98 object_class_is_abstract(oc))) {
99 return NULL;
100 }
101 return oc;
102}
103
104static void m5206_cpu_initfn(Object *obj)
105{
106 M68kCPU *cpu = M68K_CPU(obj);
107 CPUM68KState *env = &cpu->env;
108
109 m68k_set_feature(env, M68K_FEATURE_CF_ISA_A);
110}
111
112static void m68000_cpu_initfn(Object *obj)
113{
114 M68kCPU *cpu = M68K_CPU(obj);
115 CPUM68KState *env = &cpu->env;
116
117 m68k_set_feature(env, M68K_FEATURE_M68000);
118 m68k_set_feature(env, M68K_FEATURE_USP);
119 m68k_set_feature(env, M68K_FEATURE_WORD_INDEX);
120}
121
122static void m68020_cpu_initfn(Object *obj)
123{
124 M68kCPU *cpu = M68K_CPU(obj);
125 CPUM68KState *env = &cpu->env;
126
127 m68k_set_feature(env, M68K_FEATURE_M68000);
128 m68k_set_feature(env, M68K_FEATURE_USP);
129 m68k_set_feature(env, M68K_FEATURE_WORD_INDEX);
130 m68k_set_feature(env, M68K_FEATURE_QUAD_MULDIV);
131 m68k_set_feature(env, M68K_FEATURE_BRAL);
132 m68k_set_feature(env, M68K_FEATURE_BCCL);
133 m68k_set_feature(env, M68K_FEATURE_BITFIELD);
134 m68k_set_feature(env, M68K_FEATURE_EXT_FULL);
135 m68k_set_feature(env, M68K_FEATURE_SCALED_INDEX);
136 m68k_set_feature(env, M68K_FEATURE_LONG_MULDIV);
137 m68k_set_feature(env, M68K_FEATURE_FPU);
138 m68k_set_feature(env, M68K_FEATURE_CAS);
139 m68k_set_feature(env, M68K_FEATURE_BKPT);
140 m68k_set_feature(env, M68K_FEATURE_RTD);
141}
142#define m68030_cpu_initfn m68020_cpu_initfn
143#define m68040_cpu_initfn m68020_cpu_initfn
144
145static void m68060_cpu_initfn(Object *obj)
146{
147 M68kCPU *cpu = M68K_CPU(obj);
148 CPUM68KState *env = &cpu->env;
149
150 m68k_set_feature(env, M68K_FEATURE_M68000);
151 m68k_set_feature(env, M68K_FEATURE_USP);
152 m68k_set_feature(env, M68K_FEATURE_WORD_INDEX);
153 m68k_set_feature(env, M68K_FEATURE_BRAL);
154 m68k_set_feature(env, M68K_FEATURE_BCCL);
155 m68k_set_feature(env, M68K_FEATURE_BITFIELD);
156 m68k_set_feature(env, M68K_FEATURE_EXT_FULL);
157 m68k_set_feature(env, M68K_FEATURE_SCALED_INDEX);
158 m68k_set_feature(env, M68K_FEATURE_LONG_MULDIV);
159 m68k_set_feature(env, M68K_FEATURE_FPU);
160 m68k_set_feature(env, M68K_FEATURE_CAS);
161 m68k_set_feature(env, M68K_FEATURE_BKPT);
162 m68k_set_feature(env, M68K_FEATURE_RTD);
163}
164
165static void m5208_cpu_initfn(Object *obj)
166{
167 M68kCPU *cpu = M68K_CPU(obj);
168 CPUM68KState *env = &cpu->env;
169
170 m68k_set_feature(env, M68K_FEATURE_CF_ISA_A);
171 m68k_set_feature(env, M68K_FEATURE_CF_ISA_APLUSC);
172 m68k_set_feature(env, M68K_FEATURE_BRAL);
173 m68k_set_feature(env, M68K_FEATURE_CF_EMAC);
174 m68k_set_feature(env, M68K_FEATURE_USP);
175}
176
177static void cfv4e_cpu_initfn(Object *obj)
178{
179 M68kCPU *cpu = M68K_CPU(obj);
180 CPUM68KState *env = &cpu->env;
181
182 m68k_set_feature(env, M68K_FEATURE_CF_ISA_A);
183 m68k_set_feature(env, M68K_FEATURE_CF_ISA_B);
184 m68k_set_feature(env, M68K_FEATURE_BRAL);
185 m68k_set_feature(env, M68K_FEATURE_CF_FPU);
186 m68k_set_feature(env, M68K_FEATURE_CF_EMAC);
187 m68k_set_feature(env, M68K_FEATURE_USP);
188}
189
190static void any_cpu_initfn(Object *obj)
191{
192 M68kCPU *cpu = M68K_CPU(obj);
193 CPUM68KState *env = &cpu->env;
194
195 m68k_set_feature(env, M68K_FEATURE_CF_ISA_A);
196 m68k_set_feature(env, M68K_FEATURE_CF_ISA_B);
197 m68k_set_feature(env, M68K_FEATURE_CF_ISA_APLUSC);
198 m68k_set_feature(env, M68K_FEATURE_BRAL);
199 m68k_set_feature(env, M68K_FEATURE_CF_FPU);
200
201
202 m68k_set_feature(env, M68K_FEATURE_CF_EMAC);
203 m68k_set_feature(env, M68K_FEATURE_CF_EMAC_B);
204 m68k_set_feature(env, M68K_FEATURE_USP);
205 m68k_set_feature(env, M68K_FEATURE_EXT_FULL);
206 m68k_set_feature(env, M68K_FEATURE_WORD_INDEX);
207}
208
209typedef struct M68kCPUInfo {
210 const char *name;
211 void (*instance_init)(Object *obj);
212} M68kCPUInfo;
213
214static const M68kCPUInfo m68k_cpus[] = {
215 { .name = "m68000", .instance_init = m68000_cpu_initfn },
216 { .name = "m68020", .instance_init = m68020_cpu_initfn },
217 { .name = "m68030", .instance_init = m68030_cpu_initfn },
218 { .name = "m68040", .instance_init = m68040_cpu_initfn },
219 { .name = "m68060", .instance_init = m68060_cpu_initfn },
220 { .name = "m5206", .instance_init = m5206_cpu_initfn },
221 { .name = "m5208", .instance_init = m5208_cpu_initfn },
222 { .name = "cfv4e", .instance_init = cfv4e_cpu_initfn },
223 { .name = "any", .instance_init = any_cpu_initfn },
224};
225
226static void m68k_cpu_realizefn(DeviceState *dev, Error **errp)
227{
228 CPUState *cs = CPU(dev);
229 M68kCPU *cpu = M68K_CPU(dev);
230 M68kCPUClass *mcc = M68K_CPU_GET_CLASS(dev);
231 Error *local_err = NULL;
232
233 cpu_exec_realizefn(cs, &local_err);
234 if (local_err != NULL) {
235 error_propagate(errp, local_err);
236 return;
237 }
238
239 m68k_cpu_init_gdb(cpu);
240
241 cpu_reset(cs);
242 qemu_init_vcpu(cs);
243
244 mcc->parent_realize(dev, errp);
245}
246
247static void m68k_cpu_initfn(Object *obj)
248{
249 CPUState *cs = CPU(obj);
250 M68kCPU *cpu = M68K_CPU(obj);
251 CPUM68KState *env = &cpu->env;
252 static bool inited;
253
254 cs->env_ptr = env;
255
256 if (tcg_enabled() && !inited) {
257 inited = true;
258 m68k_tcg_init();
259 }
260}
261
262static const VMStateDescription vmstate_m68k_cpu = {
263 .name = "cpu",
264 .unmigratable = 1,
265};
266
267static void m68k_cpu_class_init(ObjectClass *c, void *data)
268{
269 M68kCPUClass *mcc = M68K_CPU_CLASS(c);
270 CPUClass *cc = CPU_CLASS(c);
271 DeviceClass *dc = DEVICE_CLASS(c);
272
273 mcc->parent_realize = dc->realize;
274 dc->realize = m68k_cpu_realizefn;
275
276 mcc->parent_reset = cc->reset;
277 cc->reset = m68k_cpu_reset;
278
279 cc->class_by_name = m68k_cpu_class_by_name;
280 cc->has_work = m68k_cpu_has_work;
281 cc->do_interrupt = m68k_cpu_do_interrupt;
282 cc->cpu_exec_interrupt = m68k_cpu_exec_interrupt;
283 cc->dump_state = m68k_cpu_dump_state;
284 cc->set_pc = m68k_cpu_set_pc;
285 cc->gdb_read_register = m68k_cpu_gdb_read_register;
286 cc->gdb_write_register = m68k_cpu_gdb_write_register;
287#ifdef CONFIG_USER_ONLY
288 cc->handle_mmu_fault = m68k_cpu_handle_mmu_fault;
289#else
290 cc->get_phys_page_debug = m68k_cpu_get_phys_page_debug;
291#endif
292 cc->disas_set_info = m68k_cpu_disas_set_info;
293
294 cc->gdb_num_core_regs = 18;
295 cc->gdb_core_xml_file = "cf-core.xml";
296
297 dc->vmsd = &vmstate_m68k_cpu;
298}
299
300static void register_cpu_type(const M68kCPUInfo *info)
301{
302 TypeInfo type_info = {
303 .parent = TYPE_M68K_CPU,
304 .instance_init = info->instance_init,
305 };
306
307 type_info.name = g_strdup_printf("%s-" TYPE_M68K_CPU, info->name);
308 type_register(&type_info);
309 g_free((void *)type_info.name);
310}
311
312static const TypeInfo m68k_cpu_type_info = {
313 .name = TYPE_M68K_CPU,
314 .parent = TYPE_CPU,
315 .instance_size = sizeof(M68kCPU),
316 .instance_init = m68k_cpu_initfn,
317 .abstract = true,
318 .class_size = sizeof(M68kCPUClass),
319 .class_init = m68k_cpu_class_init,
320};
321
322static void m68k_cpu_register_types(void)
323{
324 int i;
325
326 type_register_static(&m68k_cpu_type_info);
327 for (i = 0; i < ARRAY_SIZE(m68k_cpus); i++) {
328 register_cpu_type(&m68k_cpus[i]);
329 }
330}
331
332type_init(m68k_cpu_register_types)
333