1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include "qemu/osdep.h"
21#include "qapi/error.h"
22#include "cpu.h"
23#include "qemu-common.h"
24
25static inline void set_feature(CPUTriCoreState *env, int feature)
26{
27 env->features |= 1ULL << feature;
28}
29
30static void tricore_cpu_set_pc(CPUState *cs, vaddr value)
31{
32 TriCoreCPU *cpu = TRICORE_CPU(cs);
33 CPUTriCoreState *env = &cpu->env;
34
35 env->PC = value & ~(target_ulong)1;
36}
37
38static void tricore_cpu_synchronize_from_tb(CPUState *cs,
39 TranslationBlock *tb)
40{
41 TriCoreCPU *cpu = TRICORE_CPU(cs);
42 CPUTriCoreState *env = &cpu->env;
43
44 env->PC = tb->pc;
45}
46
47static void tricore_cpu_reset(CPUState *s)
48{
49 TriCoreCPU *cpu = TRICORE_CPU(s);
50 TriCoreCPUClass *tcc = TRICORE_CPU_GET_CLASS(cpu);
51 CPUTriCoreState *env = &cpu->env;
52
53 tcc->parent_reset(s);
54
55 tlb_flush(s, 1);
56
57 cpu_state_reset(env);
58}
59
60static bool tricore_cpu_has_work(CPUState *cs)
61{
62 return true;
63}
64
65static void tricore_cpu_realizefn(DeviceState *dev, Error **errp)
66{
67 CPUState *cs = CPU(dev);
68 TriCoreCPU *cpu = TRICORE_CPU(dev);
69 TriCoreCPUClass *tcc = TRICORE_CPU_GET_CLASS(dev);
70 CPUTriCoreState *env = &cpu->env;
71
72
73 if (tricore_feature(env, TRICORE_FEATURE_161)) {
74 set_feature(env, TRICORE_FEATURE_16);
75 }
76
77 if (tricore_feature(env, TRICORE_FEATURE_16)) {
78 set_feature(env, TRICORE_FEATURE_131);
79 }
80 if (tricore_feature(env, TRICORE_FEATURE_131)) {
81 set_feature(env, TRICORE_FEATURE_13);
82 }
83 cpu_reset(cs);
84 qemu_init_vcpu(cs);
85
86 tcc->parent_realize(dev, errp);
87}
88
89
90static void tricore_cpu_initfn(Object *obj)
91{
92 CPUState *cs = CPU(obj);
93 TriCoreCPU *cpu = TRICORE_CPU(obj);
94 CPUTriCoreState *env = &cpu->env;
95
96 cs->env_ptr = env;
97 cpu_exec_init(cs, &error_abort);
98
99 if (tcg_enabled()) {
100 tricore_tcg_init();
101 }
102}
103
104static ObjectClass *tricore_cpu_class_by_name(const char *cpu_model)
105{
106 ObjectClass *oc;
107 char *typename;
108
109 if (!cpu_model) {
110 return NULL;
111 }
112
113 typename = g_strdup_printf("%s-" TYPE_TRICORE_CPU, cpu_model);
114 oc = object_class_by_name(typename);
115 g_free(typename);
116 if (!oc || !object_class_dynamic_cast(oc, TYPE_TRICORE_CPU) ||
117 object_class_is_abstract(oc)) {
118 return NULL;
119 }
120 return oc;
121}
122
123static void tc1796_initfn(Object *obj)
124{
125 TriCoreCPU *cpu = TRICORE_CPU(obj);
126
127 set_feature(&cpu->env, TRICORE_FEATURE_13);
128}
129
130static void tc1797_initfn(Object *obj)
131{
132 TriCoreCPU *cpu = TRICORE_CPU(obj);
133
134 set_feature(&cpu->env, TRICORE_FEATURE_131);
135}
136
137static void tc27x_initfn(Object *obj)
138{
139 TriCoreCPU *cpu = TRICORE_CPU(obj);
140
141 set_feature(&cpu->env, TRICORE_FEATURE_161);
142}
143
144typedef struct TriCoreCPUInfo {
145 const char *name;
146 void (*initfn)(Object *obj);
147 void (*class_init)(ObjectClass *oc, void *data);
148} TriCoreCPUInfo;
149
150static const TriCoreCPUInfo tricore_cpus[] = {
151 { .name = "tc1796", .initfn = tc1796_initfn },
152 { .name = "tc1797", .initfn = tc1797_initfn },
153 { .name = "tc27x", .initfn = tc27x_initfn },
154 { .name = NULL }
155};
156
157static void tricore_cpu_class_init(ObjectClass *c, void *data)
158{
159 TriCoreCPUClass *mcc = TRICORE_CPU_CLASS(c);
160 CPUClass *cc = CPU_CLASS(c);
161 DeviceClass *dc = DEVICE_CLASS(c);
162
163 mcc->parent_realize = dc->realize;
164 dc->realize = tricore_cpu_realizefn;
165
166 mcc->parent_reset = cc->reset;
167 cc->reset = tricore_cpu_reset;
168 cc->class_by_name = tricore_cpu_class_by_name;
169 cc->has_work = tricore_cpu_has_work;
170
171 cc->dump_state = tricore_cpu_dump_state;
172 cc->set_pc = tricore_cpu_set_pc;
173 cc->synchronize_from_tb = tricore_cpu_synchronize_from_tb;
174
175
176
177
178
179
180 dc->cannot_destroy_with_object_finalize_yet = true;
181}
182
183static void cpu_register(const TriCoreCPUInfo *info)
184{
185 TypeInfo type_info = {
186 .parent = TYPE_TRICORE_CPU,
187 .instance_size = sizeof(TriCoreCPU),
188 .instance_init = info->initfn,
189 .class_size = sizeof(TriCoreCPUClass),
190 .class_init = info->class_init,
191 };
192
193 type_info.name = g_strdup_printf("%s-" TYPE_TRICORE_CPU, info->name);
194 type_register(&type_info);
195 g_free((void *)type_info.name);
196}
197
198static const TypeInfo tricore_cpu_type_info = {
199 .name = TYPE_TRICORE_CPU,
200 .parent = TYPE_CPU,
201 .instance_size = sizeof(TriCoreCPU),
202 .instance_init = tricore_cpu_initfn,
203 .abstract = true,
204 .class_size = sizeof(TriCoreCPUClass),
205 .class_init = tricore_cpu_class_init,
206};
207
208static void tricore_cpu_register_types(void)
209{
210 const TriCoreCPUInfo *info = tricore_cpus;
211
212 type_register_static(&tricore_cpu_type_info);
213
214 while (info->name) {
215 cpu_register(info);
216 info++;
217 }
218}
219
220type_init(tricore_cpu_register_types)
221