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