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