1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "qemu/osdep.h"
25#include "qemu/units.h"
26#include "qemu/error-report.h"
27#include "qapi/error.h"
28#include "qemu-common.h"
29#include "cpu.h"
30#include "hw/hw.h"
31#include "qemu/timer.h"
32#include "hw/ptimer.h"
33#include "sysemu/sysemu.h"
34#include "sysemu/qtest.h"
35#include "hw/boards.h"
36#include "hw/loader.h"
37#include "elf.h"
38#include "trace.h"
39#include "exec/address-spaces.h"
40
41#include "hw/sparc/grlib.h"
42
43
44#define CPU_CLK (40 * 1000 * 1000)
45
46#define PROM_FILENAME "u-boot.bin"
47
48#define MAX_PILS 16
49
50typedef struct ResetData {
51 SPARCCPU *cpu;
52 uint32_t entry;
53 target_ulong sp;
54} ResetData;
55
56static void main_cpu_reset(void *opaque)
57{
58 ResetData *s = (ResetData *)opaque;
59 CPUState *cpu = CPU(s->cpu);
60 CPUSPARCState *env = &s->cpu->env;
61
62 cpu_reset(cpu);
63
64 cpu->halted = 0;
65 env->pc = s->entry;
66 env->npc = s->entry + 4;
67 env->regbase[6] = s->sp;
68}
69
70void leon3_irq_ack(void *irq_manager, int intno)
71{
72 grlib_irqmp_ack((DeviceState *)irq_manager, intno);
73}
74
75static void leon3_set_pil_in(void *opaque, uint32_t pil_in)
76{
77 CPUSPARCState *env = (CPUSPARCState *)opaque;
78 CPUState *cs;
79
80 assert(env != NULL);
81
82 env->pil_in = pil_in;
83
84 if (env->pil_in && (env->interrupt_index == 0 ||
85 (env->interrupt_index & ~15) == TT_EXTINT)) {
86 unsigned int i;
87
88 for (i = 15; i > 0; i--) {
89 if (env->pil_in & (1 << i)) {
90 int old_interrupt = env->interrupt_index;
91
92 env->interrupt_index = TT_EXTINT | i;
93 if (old_interrupt != env->interrupt_index) {
94 cs = CPU(sparc_env_get_cpu(env));
95 trace_leon3_set_irq(i);
96 cpu_interrupt(cs, CPU_INTERRUPT_HARD);
97 }
98 break;
99 }
100 }
101 } else if (!env->pil_in && (env->interrupt_index & ~15) == TT_EXTINT) {
102 cs = CPU(sparc_env_get_cpu(env));
103 trace_leon3_reset_irq(env->interrupt_index & 15);
104 env->interrupt_index = 0;
105 cpu_reset_interrupt(cs, CPU_INTERRUPT_HARD);
106 }
107}
108
109static void leon3_generic_hw_init(MachineState *machine)
110{
111 ram_addr_t ram_size = machine->ram_size;
112 const char *kernel_filename = machine->kernel_filename;
113 SPARCCPU *cpu;
114 CPUSPARCState *env;
115 MemoryRegion *address_space_mem = get_system_memory();
116 MemoryRegion *ram = g_new(MemoryRegion, 1);
117 MemoryRegion *prom = g_new(MemoryRegion, 1);
118 int ret;
119 char *filename;
120 qemu_irq *cpu_irqs = NULL;
121 int bios_size;
122 int prom_size;
123 ResetData *reset_info;
124
125
126 cpu = SPARC_CPU(cpu_create(machine->cpu_type));
127 env = &cpu->env;
128
129 cpu_sparc_set_id(env, 0);
130
131
132 reset_info = g_malloc0(sizeof(ResetData));
133 reset_info->cpu = cpu;
134 reset_info->sp = 0x40000000 + ram_size;
135 qemu_register_reset(main_cpu_reset, reset_info);
136
137
138 grlib_irqmp_create(0x80000200, env, &cpu_irqs, MAX_PILS, &leon3_set_pil_in);
139
140 env->qemu_irq_ack = leon3_irq_manager;
141
142
143 if (ram_size > 1 * GiB) {
144 error_report("Too much memory for this machine: %" PRId64 "MB,"
145 " maximum 1G",
146 ram_size / MiB);
147 exit(1);
148 }
149
150 memory_region_allocate_system_memory(ram, NULL, "leon3.ram", ram_size);
151 memory_region_add_subregion(address_space_mem, 0x40000000, ram);
152
153
154 prom_size = 8 * MiB;
155 memory_region_init_ram(prom, NULL, "Leon3.bios", prom_size, &error_fatal);
156 memory_region_set_readonly(prom, true);
157 memory_region_add_subregion(address_space_mem, 0x00000000, prom);
158
159
160 if (bios_name == NULL) {
161 bios_name = PROM_FILENAME;
162 }
163 filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
164
165 if (filename) {
166 bios_size = get_image_size(filename);
167 } else {
168 bios_size = -1;
169 }
170
171 if (bios_size > prom_size) {
172 error_report("could not load prom '%s': file too big", filename);
173 exit(1);
174 }
175
176 if (bios_size > 0) {
177 ret = load_image_targphys(filename, 0x00000000, bios_size);
178 if (ret < 0 || ret > prom_size) {
179 error_report("could not load prom '%s'", filename);
180 exit(1);
181 }
182 } else if (kernel_filename == NULL && !qtest_enabled()) {
183 error_report("Can't read bios image %s", filename);
184 exit(1);
185 }
186 g_free(filename);
187
188
189 if (kernel_filename != NULL) {
190 long kernel_size;
191 uint64_t entry;
192
193 kernel_size = load_elf(kernel_filename, NULL, NULL, NULL,
194 &entry, NULL, NULL,
195 1 , EM_SPARC, 0, 0);
196 if (kernel_size < 0) {
197 error_report("could not load kernel '%s'", kernel_filename);
198 exit(1);
199 }
200 if (bios_size <= 0) {
201
202 env->pc = entry;
203 env->npc = entry + 4;
204 reset_info->entry = entry;
205 }
206 }
207
208
209 grlib_gptimer_create(0x80000300, 2, CPU_CLK, cpu_irqs, 6);
210
211
212 if (serial_hd(0)) {
213 grlib_apbuart_create(0x80000100, serial_hd(0), cpu_irqs[3]);
214 }
215}
216
217static void leon3_generic_machine_init(MachineClass *mc)
218{
219 mc->desc = "Leon-3 generic";
220 mc->init = leon3_generic_hw_init;
221 mc->default_cpu_type = SPARC_CPU_TYPE_NAME("LEON3");
222}
223
224DEFINE_MACHINE("leon3_generic", leon3_generic_machine_init)
225