target/tricore/cpu.c

   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 "exec/exec-all.h"
  24 #include "qemu/error-report.h"
  25
  26 static inline void set_feature(CPUTriCoreState *env, int feature)
  27 {
  28     env->features |= 1ULL << feature;
  29 }
  30
  31 static gchar *tricore_gdb_arch_name(CPUState *cs)
  32 {
  33     return g_strdup("tricore");
  34 }
  35
  36 static void tricore_cpu_set_pc(CPUState *cs, vaddr value)
  37 {
  38     TriCoreCPU *cpu = TRICORE_CPU(cs);
  39     CPUTriCoreState *env = &cpu->env;
  40
  41     env->PC = value & ~(target_ulong)1;
  42 }
  43
  44 static vaddr tricore_cpu_get_pc(CPUState *cs)
  45 {
  46     TriCoreCPU *cpu = TRICORE_CPU(cs);
  47     CPUTriCoreState *env = &cpu->env;
  48
  49     return env->PC;
  50 }
  51
  52 static void tricore_cpu_synchronize_from_tb(CPUState *cs,
  53                                             const TranslationBlock *tb)
  54 {
  55     TriCoreCPU *cpu = TRICORE_CPU(cs);
  56     CPUTriCoreState *env = &cpu->env;
  57
  58     env->PC = tb->pc;
  59 }
  60
  61 static void tricore_cpu_reset(DeviceState *dev)
  62 {
  63     CPUState *s = CPU(dev);
  64     TriCoreCPU *cpu = TRICORE_CPU(s);
  65     TriCoreCPUClass *tcc = TRICORE_CPU_GET_CLASS(cpu);
  66     CPUTriCoreState *env = &cpu->env;
  67
  68     tcc->parent_reset(dev);
  69
  70     cpu_state_reset(env);
  71 }
  72
  73 static bool tricore_cpu_has_work(CPUState *cs)
  74 {
  75     return true;
  76 }
  77
  78 static void tricore_cpu_realizefn(DeviceState *dev, Error **errp)
  79 {
  80     CPUState *cs = CPU(dev);
  81     TriCoreCPU *cpu = TRICORE_CPU(dev);
  82     TriCoreCPUClass *tcc = TRICORE_CPU_GET_CLASS(dev);
  83     CPUTriCoreState *env = &cpu->env;
  84     Error *local_err = NULL;
  85
  86     cpu_exec_realizefn(cs, &local_err);
  87     if (local_err != NULL) {
  88         error_propagate(errp, local_err);
  89         return;
  90     }
  91
  92     /* Some features automatically imply others */
  93     if (tricore_feature(env, TRICORE_FEATURE_161)) {
  94         set_feature(env, TRICORE_FEATURE_16);
  95     }
  96
  97     if (tricore_feature(env, TRICORE_FEATURE_16)) {
  98         set_feature(env, TRICORE_FEATURE_131);
  99     }
 100     if (tricore_feature(env, TRICORE_FEATURE_131)) {
 101         set_feature(env, TRICORE_FEATURE_13);
 102     }
 103     cpu_reset(cs);
 104     qemu_init_vcpu(cs);
 105
 106     tcc->parent_realize(dev, errp);
 107 }
 108
 109
 110 static void tricore_cpu_initfn(Object *obj)
 111 {
 112     TriCoreCPU *cpu = TRICORE_CPU(obj);
 113
 114     cpu_set_cpustate_pointers(cpu);
 115 }
 116
 117 static ObjectClass *tricore_cpu_class_by_name(const char *cpu_model)
 118 {
 119     ObjectClass *oc;
 120     char *typename;
 121
 122     typename = g_strdup_printf(TRICORE_CPU_TYPE_NAME("%s"), cpu_model);
 123     oc = object_class_by_name(typename);
 124     g_free(typename);
 125     if (!oc || !object_class_dynamic_cast(oc, TYPE_TRICORE_CPU) ||
 126         object_class_is_abstract(oc)) {
 127         return NULL;
 128     }
 129     return oc;
 130 }
 131
 132 static void tc1796_initfn(Object *obj)
 133 {
 134     TriCoreCPU *cpu = TRICORE_CPU(obj);
 135
 136     set_feature(&cpu->env, TRICORE_FEATURE_13);
 137 }
 138
 139 static void tc1797_initfn(Object *obj)
 140 {
 141     TriCoreCPU *cpu = TRICORE_CPU(obj);
 142
 143     set_feature(&cpu->env, TRICORE_FEATURE_131);
 144 }
 145
 146 static void tc27x_initfn(Object *obj)
 147 {
 148     TriCoreCPU *cpu = TRICORE_CPU(obj);
 149
 150     set_feature(&cpu->env, TRICORE_FEATURE_161);
 151 }
 152
 153 #include "hw/core/sysemu-cpu-ops.h"
 154
 155 static const struct SysemuCPUOps tricore_sysemu_ops = {
 156     .get_phys_page_debug = tricore_cpu_get_phys_page_debug,
 157 };
 158
 159 #include "hw/core/tcg-cpu-ops.h"
 160
 161 static const struct TCGCPUOps tricore_tcg_ops = {
 162     .initialize = tricore_tcg_init,
 163     .synchronize_from_tb = tricore_cpu_synchronize_from_tb,
 164     .tlb_fill = tricore_cpu_tlb_fill,
 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     device_class_set_parent_realize(dc, tricore_cpu_realizefn,
 174                                     &mcc->parent_realize);
 175
 176     device_class_set_parent_reset(dc, tricore_cpu_reset, &mcc->parent_reset);
 177     cc->class_by_name = tricore_cpu_class_by_name;
 178     cc->has_work = tricore_cpu_has_work;
 179
 180     cc->gdb_read_register = tricore_cpu_gdb_read_register;
 181     cc->gdb_write_register = tricore_cpu_gdb_write_register;
 182     cc->gdb_num_core_regs = 44;
 183     cc->gdb_arch_name = tricore_gdb_arch_name;
 184
 185     cc->dump_state = tricore_cpu_dump_state;
 186     cc->set_pc = tricore_cpu_set_pc;
 187     cc->get_pc = tricore_cpu_get_pc;
 188     cc->sysemu_ops = &tricore_sysemu_ops;
 189     cc->tcg_ops = &tricore_tcg_ops;
 190 }
 191
 192 #define DEFINE_TRICORE_CPU_TYPE(cpu_model, initfn) \
 193     {                                              \
 194         .parent = TYPE_TRICORE_CPU,                \
 195         .instance_init = initfn,                   \
 196         .name = TRICORE_CPU_TYPE_NAME(cpu_model),  \
 197     }
 198
 199 static const TypeInfo tricore_cpu_type_infos[] = {
 200     {
 201         .name = TYPE_TRICORE_CPU,
 202         .parent = TYPE_CPU,
 203         .instance_size = sizeof(TriCoreCPU),
 204         .instance_init = tricore_cpu_initfn,
 205         .abstract = true,
 206         .class_size = sizeof(TriCoreCPUClass),
 207         .class_init = tricore_cpu_class_init,
 208     },
 209     DEFINE_TRICORE_CPU_TYPE("tc1796", tc1796_initfn),
 210     DEFINE_TRICORE_CPU_TYPE("tc1797", tc1797_initfn),
 211     DEFINE_TRICORE_CPU_TYPE("tc27x", tc27x_initfn),
 212 };
 213
 214 DEFINE_TYPES(tricore_cpu_type_infos)