trap signals for "-serial mon:stdio"
[qemu.git] / target-moxie / cpu.c
1 /*
2 * QEMU Moxie CPU
3 *
4 * Copyright (c) 2013 Anthony Green
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "cpu.h"
21 #include "qemu-common.h"
22 #include "migration/vmstate.h"
23 #include "machine.h"
24
25 static void moxie_cpu_reset(CPUState *s)
26 {
27 MoxieCPU *cpu = MOXIE_CPU(s);
28 MoxieCPUClass *mcc = MOXIE_CPU_GET_CLASS(cpu);
29 CPUMoxieState *env = &cpu->env;
30
31 if (qemu_loglevel_mask(CPU_LOG_RESET)) {
32 qemu_log("CPU Reset (CPU %d)\n", s->cpu_index);
33 log_cpu_state(env, 0);
34 }
35
36 mcc->parent_reset(s);
37
38 memset(env, 0, offsetof(CPUMoxieState, breakpoints));
39 env->pc = 0x1000;
40
41 tlb_flush(env, 1);
42 }
43
44 static void moxie_cpu_realizefn(DeviceState *dev, Error **errp)
45 {
46 MoxieCPU *cpu = MOXIE_CPU(dev);
47 MoxieCPUClass *mcc = MOXIE_CPU_GET_CLASS(dev);
48
49 cpu_reset(CPU(cpu));
50
51 mcc->parent_realize(dev, errp);
52 }
53
54 static void moxie_cpu_initfn(Object *obj)
55 {
56 CPUState *cs = CPU(obj);
57 MoxieCPU *cpu = MOXIE_CPU(obj);
58 static int inited;
59
60 cs->env_ptr = &cpu->env;
61 cpu_exec_init(&cpu->env);
62
63 if (tcg_enabled() && !inited) {
64 inited = 1;
65 moxie_translate_init();
66 }
67 }
68
69 static ObjectClass *moxie_cpu_class_by_name(const char *cpu_model)
70 {
71 ObjectClass *oc;
72
73 if (cpu_model == NULL) {
74 return NULL;
75 }
76
77 oc = object_class_by_name(cpu_model);
78 if (oc != NULL && (!object_class_dynamic_cast(oc, TYPE_MOXIE_CPU) ||
79 object_class_is_abstract(oc))) {
80 return NULL;
81 }
82 return oc;
83 }
84
85 static void moxie_cpu_class_init(ObjectClass *oc, void *data)
86 {
87 DeviceClass *dc = DEVICE_CLASS(oc);
88 CPUClass *cc = CPU_CLASS(oc);
89 MoxieCPUClass *mcc = MOXIE_CPU_CLASS(oc);
90
91 mcc->parent_realize = dc->realize;
92 dc->realize = moxie_cpu_realizefn;
93
94 mcc->parent_reset = cc->reset;
95 cc->reset = moxie_cpu_reset;
96
97 cc->class_by_name = moxie_cpu_class_by_name;
98
99 cc->do_interrupt = moxie_cpu_do_interrupt;
100 cc->dump_state = moxie_cpu_dump_state;
101 cpu_class_set_vmsd(cc, &vmstate_moxie_cpu);
102 }
103
104 static void moxielite_initfn(Object *obj)
105 {
106 /* Set cpu feature flags */
107 }
108
109 static void moxie_any_initfn(Object *obj)
110 {
111 /* Set cpu feature flags */
112 }
113
114 typedef struct MoxieCPUInfo {
115 const char *name;
116 void (*initfn)(Object *obj);
117 } MoxieCPUInfo;
118
119 static const MoxieCPUInfo moxie_cpus[] = {
120 { .name = "MoxieLite", .initfn = moxielite_initfn },
121 { .name = "any", .initfn = moxie_any_initfn },
122 };
123
124 MoxieCPU *cpu_moxie_init(const char *cpu_model)
125 {
126 MoxieCPU *cpu;
127 ObjectClass *oc;
128
129 oc = moxie_cpu_class_by_name(cpu_model);
130 if (oc == NULL) {
131 return NULL;
132 }
133 cpu = MOXIE_CPU(object_new(object_class_get_name(oc)));
134 cpu->env.cpu_model_str = cpu_model;
135
136 object_property_set_bool(OBJECT(cpu), true, "realized", NULL);
137
138 return cpu;
139 }
140
141 static void cpu_register(const MoxieCPUInfo *info)
142 {
143 TypeInfo type_info = {
144 .parent = TYPE_MOXIE_CPU,
145 .instance_size = sizeof(MoxieCPU),
146 .instance_init = info->initfn,
147 .class_size = sizeof(MoxieCPUClass),
148 };
149
150 type_info.name = g_strdup_printf("%s-" TYPE_MOXIE_CPU, info->name);
151 type_register(&type_info);
152 g_free((void *)type_info.name);
153 }
154
155 static const TypeInfo moxie_cpu_type_info = {
156 .name = TYPE_MOXIE_CPU,
157 .parent = TYPE_CPU,
158 .instance_size = sizeof(MoxieCPU),
159 .instance_init = moxie_cpu_initfn,
160 .class_size = sizeof(MoxieCPUClass),
161 .class_init = moxie_cpu_class_init,
162 };
163
164 static void moxie_cpu_register_types(void)
165 {
166 int i;
167 type_register_static(&moxie_cpu_type_info);
168 for (i = 0; i < ARRAY_SIZE(moxie_cpus); i++) {
169 cpu_register(&moxie_cpus[i]);
170 }
171 }
172
173 type_init(moxie_cpu_register_types)