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.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 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 114 static ObjectClass *tricore_cpu_class_by_name(const char *cpu_model) 115 { 116 ObjectClass *oc; 117 char *typename; 118 119 typename = g_strdup_printf(TRICORE_CPU_TYPE_NAME("%s"), cpu_model); 120 oc = object_class_by_name(typename); 121 g_free(typename); 122 if (!oc || !object_class_dynamic_cast(oc, TYPE_TRICORE_CPU) || 123 object_class_is_abstract(oc)) { 124 return NULL; 125 } 126 return oc; 127 } 128 129 static void tc1796_initfn(Object *obj) 130 { 131 TriCoreCPU *cpu = TRICORE_CPU(obj); 132 133 set_feature(&cpu->env, TRICORE_FEATURE_13); 134 } 135 136 static void tc1797_initfn(Object *obj) 137 { 138 TriCoreCPU *cpu = TRICORE_CPU(obj); 139 140 set_feature(&cpu->env, TRICORE_FEATURE_131); 141 } 142 143 static void tc27x_initfn(Object *obj) 144 { 145 TriCoreCPU *cpu = TRICORE_CPU(obj); 146 147 set_feature(&cpu->env, TRICORE_FEATURE_161); 148 } 149 150 static void tricore_cpu_class_init(ObjectClass *c, void *data) 151 { 152 TriCoreCPUClass *mcc = TRICORE_CPU_CLASS(c); 153 CPUClass *cc = CPU_CLASS(c); 154 DeviceClass *dc = DEVICE_CLASS(c); 155 156 device_class_set_parent_realize(dc, tricore_cpu_realizefn, 157 &mcc->parent_realize); 158 159 mcc->parent_reset = cc->reset; 160 cc->reset = tricore_cpu_reset; 161 cc->class_by_name = tricore_cpu_class_by_name; 162 cc->has_work = tricore_cpu_has_work; 163 164 cc->dump_state = tricore_cpu_dump_state; 165 cc->set_pc = tricore_cpu_set_pc; 166 cc->synchronize_from_tb = tricore_cpu_synchronize_from_tb; 167 cc->get_phys_page_attrs_debug = tricore_cpu_get_phys_page_attrs_debug; 168 cc->tcg_initialize = tricore_tcg_init; 169 } 170 171 #define DEFINE_TRICORE_CPU_TYPE(cpu_model, initfn) \ 172 { \ 173 .parent = TYPE_TRICORE_CPU, \ 174 .instance_init = initfn, \ 175 .name = TRICORE_CPU_TYPE_NAME(cpu_model), \ 176 } 177 178 static const TypeInfo tricore_cpu_type_infos[] = { 179 { 180 .name = TYPE_TRICORE_CPU, 181 .parent = TYPE_CPU, 182 .instance_size = sizeof(TriCoreCPU), 183 .instance_init = tricore_cpu_initfn, 184 .abstract = true, 185 .class_size = sizeof(TriCoreCPUClass), 186 .class_init = tricore_cpu_class_init, 187 }, 188 DEFINE_TRICORE_CPU_TYPE("tc1796", tc1796_initfn), 189 DEFINE_TRICORE_CPU_TYPE("tc1797", tc1797_initfn), 190 DEFINE_TRICORE_CPU_TYPE("tc27x", tc27x_initfn), 191 }; 192 193 DEFINE_TYPES(tricore_cpu_type_infos) 194