]> git.proxmox.com Git - qemu.git/blob - hw/mips_malta.c
projects / qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Rearrange block headers
[qemu.git] / hw / mips_malta.c
1 /*
2 * QEMU Malta board support
3 *
4 * Copyright (c) 2006 Aurelien Jarno
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 #include "hw.h"
26 #include "pc.h"
27 #include "fdc.h"
28 #include "net.h"
29 #include "boards.h"
30 #include "smbus.h"
31 #include "block.h"
32 #include "flash.h"
33 #include "mips.h"
34 #include "mips_cpudevs.h"
35 #include "pci.h"
36 #include "usb-uhci.h"
37 #include "vmware_vga.h"
38 #include "qemu-char.h"
39 #include "sysemu.h"
40 #include "audio/audio.h"
41 #include "boards.h"
42 #include "qemu-log.h"
43 #include "mips-bios.h"
44 #include "ide.h"
45 #include "loader.h"
46 #include "elf.h"
47 #include "mc146818rtc.h"
48 #include "blockdev.h"
49
50 //#define DEBUG_BOARD_INIT
51
52 #define ENVP_ADDR 0x80002000l
53 #define ENVP_NB_ENTRIES 16
54 #define ENVP_ENTRY_SIZE 256
55
56 #define MAX_IDE_BUS 2
57
58 typedef struct {
59 uint32_t leds;
60 uint32_t brk;
61 uint32_t gpout;
62 uint32_t i2cin;
63 uint32_t i2coe;
64 uint32_t i2cout;
65 uint32_t i2csel;
66 CharDriverState *display;
67 char display_text[9];
68 SerialState *uart;
69 } MaltaFPGAState;
70
71 static PITState *pit;
72
73 static struct _loaderparams {
74 int ram_size;
75 const char *kernel_filename;
76 const char *kernel_cmdline;
77 const char *initrd_filename;
78 } loaderparams;
79
80 /* Malta FPGA */
81 static void malta_fpga_update_display(void *opaque)
82 {
83 char leds_text[9];
84 int i;
85 MaltaFPGAState *s = opaque;
86
87 for (i = 7 ; i >= 0 ; i--) {
88 if (s->leds & (1 << i))
89 leds_text[i] = '#';
90 else
91 leds_text[i] = ' ';
92 }
93 leds_text[8] = '\0';
94
95 qemu_chr_printf(s->display, "\e[H\n\n|\e[32m%-8.8s\e[00m|\r\n", leds_text);
96 qemu_chr_printf(s->display, "\n\n\n\n|\e[31m%-8.8s\e[00m|", s->display_text);
97 }
98
99 /*
100 * EEPROM 24C01 / 24C02 emulation.
101 *
102 * Emulation for serial EEPROMs:
103 * 24C01 - 1024 bit (128 x 8)
104 * 24C02 - 2048 bit (256 x 8)
105 *
106 * Typical device names include Microchip 24C02SC or SGS Thomson ST24C02.
107 */
108
109 //~ #define DEBUG
110
111 #if defined(DEBUG)
112 # define logout(fmt, ...) fprintf(stderr, "MALTA\t%-24s" fmt, __func__, ## __VA_ARGS__)
113 #else
114 # define logout(fmt, ...) ((void)0)
115 #endif
116
117 struct _eeprom24c0x_t {
118 uint8_t tick;
119 uint8_t address;
120 uint8_t command;
121 uint8_t ack;
122 uint8_t scl;
123 uint8_t sda;
124 uint8_t data;
125 //~ uint16_t size;
126 uint8_t contents[256];
127 };
128
129 typedef struct _eeprom24c0x_t eeprom24c0x_t;
130
131 static eeprom24c0x_t eeprom = {
132 .contents = {
133 /* 00000000: */ 0x80,0x08,0x04,0x0D,0x0A,0x01,0x40,0x00,
134 /* 00000008: */ 0x01,0x75,0x54,0x00,0x82,0x08,0x00,0x01,
135 /* 00000010: */ 0x8F,0x04,0x02,0x01,0x01,0x00,0x0E,0x00,
136 /* 00000018: */ 0x00,0x00,0x00,0x14,0x0F,0x14,0x2D,0x40,
137 /* 00000020: */ 0x15,0x08,0x15,0x08,0x00,0x00,0x00,0x00,
138 /* 00000028: */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
139 /* 00000030: */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
140 /* 00000038: */ 0x00,0x00,0x00,0x00,0x00,0x00,0x12,0xD0,
141 /* 00000040: */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
142 /* 00000048: */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
143 /* 00000050: */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
144 /* 00000058: */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
145 /* 00000060: */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
146 /* 00000068: */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
147 /* 00000070: */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
148 /* 00000078: */ 0x00,0x00,0x00,0x00,0x00,0x00,0x64,0xF4,
149 },
150 };
151
152 static uint8_t eeprom24c0x_read(void)
153 {
154 logout("%u: scl = %u, sda = %u, data = 0x%02x\n",
155 eeprom.tick, eeprom.scl, eeprom.sda, eeprom.data);
156 return eeprom.sda;
157 }
158
159 static void eeprom24c0x_write(int scl, int sda)
160 {
161 if (eeprom.scl && scl && (eeprom.sda != sda)) {
162 logout("%u: scl = %u->%u, sda = %u->%u i2c %s\n",
163 eeprom.tick, eeprom.scl, scl, eeprom.sda, sda, sda ? "stop" : "start");
164 if (!sda) {
165 eeprom.tick = 1;
166 eeprom.command = 0;
167 }
168 } else if (eeprom.tick == 0 && !eeprom.ack) {
169 /* Waiting for start. */
170 logout("%u: scl = %u->%u, sda = %u->%u wait for i2c start\n",
171 eeprom.tick, eeprom.scl, scl, eeprom.sda, sda);
172 } else if (!eeprom.scl && scl) {
173 logout("%u: scl = %u->%u, sda = %u->%u trigger bit\n",
174 eeprom.tick, eeprom.scl, scl, eeprom.sda, sda);
175 if (eeprom.ack) {
176 logout("\ti2c ack bit = 0\n");
177 sda = 0;
178 eeprom.ack = 0;
179 } else if (eeprom.sda == sda) {
180 uint8_t bit = (sda != 0);
181 logout("\ti2c bit = %d\n", bit);
182 if (eeprom.tick < 9) {
183 eeprom.command <<= 1;
184 eeprom.command += bit;
185 eeprom.tick++;
186 if (eeprom.tick == 9) {
187 logout("\tcommand 0x%04x, %s\n", eeprom.command, bit ? "read" : "write");
188 eeprom.ack = 1;
189 }
190 } else if (eeprom.tick < 17) {
191 if (eeprom.command & 1) {
192 sda = ((eeprom.data & 0x80) != 0);
193 }
194 eeprom.address <<= 1;
195 eeprom.address += bit;
196 eeprom.tick++;
197 eeprom.data <<= 1;
198 if (eeprom.tick == 17) {
199 eeprom.data = eeprom.contents[eeprom.address];
200 logout("\taddress 0x%04x, data 0x%02x\n", eeprom.address, eeprom.data);
201 eeprom.ack = 1;
202 eeprom.tick = 0;
203 }
204 } else if (eeprom.tick >= 17) {
205 sda = 0;
206 }
207 } else {
208 logout("\tsda changed with raising scl\n");
209 }
210 } else {
211 logout("%u: scl = %u->%u, sda = %u->%u\n", eeprom.tick, eeprom.scl, scl, eeprom.sda, sda);
212 }
213 eeprom.scl = scl;
214 eeprom.sda = sda;
215 }
216
217 static uint32_t malta_fpga_readl(void *opaque, target_phys_addr_t addr)
218 {
219 MaltaFPGAState *s = opaque;
220 uint32_t val = 0;
221 uint32_t saddr;
222
223 saddr = (addr & 0xfffff);
224
225 switch (saddr) {
226
227 /* SWITCH Register */
228 case 0x00200:
229 val = 0x00000000; /* All switches closed */
230 break;
231
232 /* STATUS Register */
233 case 0x00208:
234 #ifdef TARGET_WORDS_BIGENDIAN
235 val = 0x00000012;
236 #else
237 val = 0x00000010;
238 #endif
239 break;
240
241 /* JMPRS Register */
242 case 0x00210:
243 val = 0x00;
244 break;
245
246 /* LEDBAR Register */
247 case 0x00408:
248 val = s->leds;
249 break;
250
251 /* BRKRES Register */
252 case 0x00508:
253 val = s->brk;
254 break;
255
256 /* UART Registers are handled directly by the serial device */
257
258 /* GPOUT Register */
259 case 0x00a00:
260 val = s->gpout;
261 break;
262
263 /* XXX: implement a real I2C controller */
264
265 /* GPINP Register */
266 case 0x00a08:
267 /* IN = OUT until a real I2C control is implemented */
268 if (s->i2csel)
269 val = s->i2cout;
270 else
271 val = 0x00;
272 break;
273
274 /* I2CINP Register */
275 case 0x00b00:
276 val = ((s->i2cin & ~1) | eeprom24c0x_read());
277 break;
278
279 /* I2COE Register */
280 case 0x00b08:
281 val = s->i2coe;
282 break;
283
284 /* I2COUT Register */
285 case 0x00b10:
286 val = s->i2cout;
287 break;
288
289 /* I2CSEL Register */
290 case 0x00b18:
291 val = s->i2csel;
292 break;
293
294 default:
295 #if 0
296 printf ("malta_fpga_read: Bad register offset 0x" TARGET_FMT_lx "\n",
297 addr);
298 #endif
299 break;
300 }
301 return val;
302 }
303
304 static void malta_fpga_writel(void *opaque, target_phys_addr_t addr,
305 uint32_t val)
306 {
307 MaltaFPGAState *s = opaque;
308 uint32_t saddr;
309
310 saddr = (addr & 0xfffff);
311
312 switch (saddr) {
313
314 /* SWITCH Register */
315 case 0x00200:
316 break;
317
318 /* JMPRS Register */
319 case 0x00210:
320 break;
321
322 /* LEDBAR Register */
323 /* XXX: implement a 8-LED array */
324 case 0x00408:
325 s->leds = val & 0xff;
326 break;
327
328 /* ASCIIWORD Register */
329 case 0x00410:
330 snprintf(s->display_text, 9, "%08X", val);
331 malta_fpga_update_display(s);
332 break;
333
334 /* ASCIIPOS0 to ASCIIPOS7 Registers */
335 case 0x00418:
336 case 0x00420:
337 case 0x00428:
338 case 0x00430:
339 case 0x00438:
340 case 0x00440:
341 case 0x00448:
342 case 0x00450:
343 s->display_text[(saddr - 0x00418) >> 3] = (char) val;
344 malta_fpga_update_display(s);
345 break;
346
347 /* SOFTRES Register */
348 case 0x00500:
349 if (val == 0x42)
350 qemu_system_reset_request ();
351 break;
352
353 /* BRKRES Register */
354 case 0x00508:
355 s->brk = val & 0xff;
356 break;
357
358 /* UART Registers are handled directly by the serial device */
359
360 /* GPOUT Register */
361 case 0x00a00:
362 s->gpout = val & 0xff;
363 break;
364
365 /* I2COE Register */
366 case 0x00b08:
367 s->i2coe = val & 0x03;
368 break;
369
370 /* I2COUT Register */
371 case 0x00b10:
372 eeprom24c0x_write(val & 0x02, val & 0x01);
373 s->i2cout = val;
374 break;
375
376 /* I2CSEL Register */
377 case 0x00b18:
378 s->i2csel = val & 0x01;
379 break;
380
381 default:
382 #if 0
383 printf ("malta_fpga_write: Bad register offset 0x" TARGET_FMT_lx "\n",
384 addr);
385 #endif
386 break;
387 }
388 }
389
390 static CPUReadMemoryFunc * const malta_fpga_read[] = {
391 malta_fpga_readl,
392 malta_fpga_readl,
393 malta_fpga_readl
394 };
395
396 static CPUWriteMemoryFunc * const malta_fpga_write[] = {
397 malta_fpga_writel,
398 malta_fpga_writel,
399 malta_fpga_writel
400 };
401
402 static void malta_fpga_reset(void *opaque)
403 {
404 MaltaFPGAState *s = opaque;
405
406 s->leds = 0x00;
407 s->brk = 0x0a;
408 s->gpout = 0x00;
409 s->i2cin = 0x3;
410 s->i2coe = 0x0;
411 s->i2cout = 0x3;
412 s->i2csel = 0x1;
413
414 s->display_text[8] = '\0';
415 snprintf(s->display_text, 9, " ");
416 }
417
418 static void malta_fpga_led_init(CharDriverState *chr)
419 {
420 qemu_chr_printf(chr, "\e[HMalta LEDBAR\r\n");
421 qemu_chr_printf(chr, "+--------+\r\n");
422 qemu_chr_printf(chr, "+ +\r\n");
423 qemu_chr_printf(chr, "+--------+\r\n");
424 qemu_chr_printf(chr, "\n");
425 qemu_chr_printf(chr, "Malta ASCII\r\n");
426 qemu_chr_printf(chr, "+--------+\r\n");
427 qemu_chr_printf(chr, "+ +\r\n");
428 qemu_chr_printf(chr, "+--------+\r\n");
429 }
430
431 static MaltaFPGAState *malta_fpga_init(target_phys_addr_t base, qemu_irq uart_irq, CharDriverState *uart_chr)
432 {
433 MaltaFPGAState *s;
434 int malta;
435
436 s = (MaltaFPGAState *)qemu_mallocz(sizeof(MaltaFPGAState));
437
438 malta = cpu_register_io_memory(malta_fpga_read,
439 malta_fpga_write, s);
440
441 cpu_register_physical_memory(base, 0x900, malta);
442 /* 0xa00 is less than a page, so will still get the right offsets. */
443 cpu_register_physical_memory(base + 0xa00, 0x100000 - 0xa00, malta);
444
445 s->display = qemu_chr_open("fpga", "vc:320x200", malta_fpga_led_init);
446
447 #ifdef TARGET_WORDS_BIGENDIAN
448 s->uart = serial_mm_init(base + 0x900, 3, uart_irq, 230400, uart_chr, 1, 1);
449 #else
450 s->uart = serial_mm_init(base + 0x900, 3, uart_irq, 230400, uart_chr, 1, 0);
451 #endif
452
453 malta_fpga_reset(s);
454 qemu_register_reset(malta_fpga_reset, s);
455
456 return s;
457 }
458
459 /* Audio support */
460 static void audio_init (PCIBus *pci_bus)
461 {
462 struct soundhw *c;
463 int audio_enabled = 0;
464
465 for (c = soundhw; !audio_enabled && c->name; ++c) {
466 audio_enabled = c->enabled;
467 }
468
469 if (audio_enabled) {
470 for (c = soundhw; c->name; ++c) {
471 if (c->enabled) {
472 c->init.init_pci(pci_bus);
473 }
474 }
475 }
476 }
477
478 /* Network support */
479 static void network_init(void)
480 {
481 int i;
482
483 for(i = 0; i < nb_nics; i++) {
484 NICInfo *nd = &nd_table[i];
485 const char *default_devaddr = NULL;
486
487 if (i == 0 && (!nd->model || strcmp(nd->model, "pcnet") == 0))
488 /* The malta board has a PCNet card using PCI SLOT 11 */
489 default_devaddr = "0b";
490
491 pci_nic_init_nofail(nd, "pcnet", default_devaddr);
492 }
493 }
494
495 /* ROM and pseudo bootloader
496
497 The following code implements a very very simple bootloader. It first
498 loads the registers a0 to a3 to the values expected by the OS, and
499 then jump at the kernel address.
500
501 The bootloader should pass the locations of the kernel arguments and
502 environment variables tables. Those tables contain the 32-bit address
503 of NULL terminated strings. The environment variables table should be
504 terminated by a NULL address.
505
506 For a simpler implementation, the number of kernel arguments is fixed
507 to two (the name of the kernel and the command line), and the two
508 tables are actually the same one.
509
510 The registers a0 to a3 should contain the following values:
511 a0 - number of kernel arguments
512 a1 - 32-bit address of the kernel arguments table
513 a2 - 32-bit address of the environment variables table
514 a3 - RAM size in bytes
515 */
516
517 static void write_bootloader (CPUState *env, uint8_t *base,
518 int64_t kernel_entry)
519 {
520 uint32_t *p;
521
522 /* Small bootloader */
523 p = (uint32_t *)base;
524 stl_raw(p++, 0x0bf00160); /* j 0x1fc00580 */
525 stl_raw(p++, 0x00000000); /* nop */
526
527 /* YAMON service vector */
528 stl_raw(base + 0x500, 0xbfc00580); /* start: */
529 stl_raw(base + 0x504, 0xbfc0083c); /* print_count: */
530 stl_raw(base + 0x520, 0xbfc00580); /* start: */
531 stl_raw(base + 0x52c, 0xbfc00800); /* flush_cache: */
532 stl_raw(base + 0x534, 0xbfc00808); /* print: */
533 stl_raw(base + 0x538, 0xbfc00800); /* reg_cpu_isr: */
534 stl_raw(base + 0x53c, 0xbfc00800); /* unred_cpu_isr: */
535 stl_raw(base + 0x540, 0xbfc00800); /* reg_ic_isr: */
536 stl_raw(base + 0x544, 0xbfc00800); /* unred_ic_isr: */
537 stl_raw(base + 0x548, 0xbfc00800); /* reg_esr: */
538 stl_raw(base + 0x54c, 0xbfc00800); /* unreg_esr: */
539 stl_raw(base + 0x550, 0xbfc00800); /* getchar: */
540 stl_raw(base + 0x554, 0xbfc00800); /* syscon_read: */
541
542
543 /* Second part of the bootloader */
544 p = (uint32_t *) (base + 0x580);
545 stl_raw(p++, 0x24040002); /* addiu a0, zero, 2 */
546 stl_raw(p++, 0x3c1d0000 | (((ENVP_ADDR - 64) >> 16) & 0xffff)); /* lui sp, high(ENVP_ADDR) */
547 stl_raw(p++, 0x37bd0000 | ((ENVP_ADDR - 64) & 0xffff)); /* ori sp, sp, low(ENVP_ADDR) */
548 stl_raw(p++, 0x3c050000 | ((ENVP_ADDR >> 16) & 0xffff)); /* lui a1, high(ENVP_ADDR) */
549 stl_raw(p++, 0x34a50000 | (ENVP_ADDR & 0xffff)); /* ori a1, a1, low(ENVP_ADDR) */
550 stl_raw(p++, 0x3c060000 | (((ENVP_ADDR + 8) >> 16) & 0xffff)); /* lui a2, high(ENVP_ADDR + 8) */
551 stl_raw(p++, 0x34c60000 | ((ENVP_ADDR + 8) & 0xffff)); /* ori a2, a2, low(ENVP_ADDR + 8) */
552 stl_raw(p++, 0x3c070000 | (loaderparams.ram_size >> 16)); /* lui a3, high(ram_size) */
553 stl_raw(p++, 0x34e70000 | (loaderparams.ram_size & 0xffff)); /* ori a3, a3, low(ram_size) */
554
555 /* Load BAR registers as done by YAMON */
556 stl_raw(p++, 0x3c09b400); /* lui t1, 0xb400 */
557
558 #ifdef TARGET_WORDS_BIGENDIAN
559 stl_raw(p++, 0x3c08df00); /* lui t0, 0xdf00 */
560 #else
561 stl_raw(p++, 0x340800df); /* ori t0, r0, 0x00df */
562 #endif
563 stl_raw(p++, 0xad280068); /* sw t0, 0x0068(t1) */
564
565 stl_raw(p++, 0x3c09bbe0); /* lui t1, 0xbbe0 */
566
567 #ifdef TARGET_WORDS_BIGENDIAN
568 stl_raw(p++, 0x3c08c000); /* lui t0, 0xc000 */
569 #else
570 stl_raw(p++, 0x340800c0); /* ori t0, r0, 0x00c0 */
571 #endif
572 stl_raw(p++, 0xad280048); /* sw t0, 0x0048(t1) */
573 #ifdef TARGET_WORDS_BIGENDIAN
574 stl_raw(p++, 0x3c084000); /* lui t0, 0x4000 */
575 #else
576 stl_raw(p++, 0x34080040); /* ori t0, r0, 0x0040 */
577 #endif
578 stl_raw(p++, 0xad280050); /* sw t0, 0x0050(t1) */
579
580 #ifdef TARGET_WORDS_BIGENDIAN
581 stl_raw(p++, 0x3c088000); /* lui t0, 0x8000 */
582 #else
583 stl_raw(p++, 0x34080080); /* ori t0, r0, 0x0080 */
584 #endif
585 stl_raw(p++, 0xad280058); /* sw t0, 0x0058(t1) */
586 #ifdef TARGET_WORDS_BIGENDIAN
587 stl_raw(p++, 0x3c083f00); /* lui t0, 0x3f00 */
588 #else
589 stl_raw(p++, 0x3408003f); /* ori t0, r0, 0x003f */
590 #endif
591 stl_raw(p++, 0xad280060); /* sw t0, 0x0060(t1) */
592
593 #ifdef TARGET_WORDS_BIGENDIAN
594 stl_raw(p++, 0x3c08c100); /* lui t0, 0xc100 */
595 #else
596 stl_raw(p++, 0x340800c1); /* ori t0, r0, 0x00c1 */
597 #endif
598 stl_raw(p++, 0xad280080); /* sw t0, 0x0080(t1) */
599 #ifdef TARGET_WORDS_BIGENDIAN
600 stl_raw(p++, 0x3c085e00); /* lui t0, 0x5e00 */
601 #else
602 stl_raw(p++, 0x3408005e); /* ori t0, r0, 0x005e */
603 #endif
604 stl_raw(p++, 0xad280088); /* sw t0, 0x0088(t1) */
605
606 /* Jump to kernel code */
607 stl_raw(p++, 0x3c1f0000 | ((kernel_entry >> 16) & 0xffff)); /* lui ra, high(kernel_entry) */
608 stl_raw(p++, 0x37ff0000 | (kernel_entry & 0xffff)); /* ori ra, ra, low(kernel_entry) */
609 stl_raw(p++, 0x03e00008); /* jr ra */
610 stl_raw(p++, 0x00000000); /* nop */
611
612 /* YAMON subroutines */
613 p = (uint32_t *) (base + 0x800);
614 stl_raw(p++, 0x03e00008); /* jr ra */
615 stl_raw(p++, 0x24020000); /* li v0,0 */
616 /* 808 YAMON print */
617 stl_raw(p++, 0x03e06821); /* move t5,ra */
618 stl_raw(p++, 0x00805821); /* move t3,a0 */
619 stl_raw(p++, 0x00a05021); /* move t2,a1 */
620 stl_raw(p++, 0x91440000); /* lbu a0,0(t2) */
621 stl_raw(p++, 0x254a0001); /* addiu t2,t2,1 */
622 stl_raw(p++, 0x10800005); /* beqz a0,834 */
623 stl_raw(p++, 0x00000000); /* nop */
624 stl_raw(p++, 0x0ff0021c); /* jal 870 */
625 stl_raw(p++, 0x00000000); /* nop */
626 stl_raw(p++, 0x08000205); /* j 814 */
627 stl_raw(p++, 0x00000000); /* nop */
628 stl_raw(p++, 0x01a00008); /* jr t5 */
629 stl_raw(p++, 0x01602021); /* move a0,t3 */
630 /* 0x83c YAMON print_count */
631 stl_raw(p++, 0x03e06821); /* move t5,ra */
632 stl_raw(p++, 0x00805821); /* move t3,a0 */
633 stl_raw(p++, 0x00a05021); /* move t2,a1 */
634 stl_raw(p++, 0x00c06021); /* move t4,a2 */
635 stl_raw(p++, 0x91440000); /* lbu a0,0(t2) */
636 stl_raw(p++, 0x0ff0021c); /* jal 870 */
637 stl_raw(p++, 0x00000000); /* nop */
638 stl_raw(p++, 0x254a0001); /* addiu t2,t2,1 */
639 stl_raw(p++, 0x258cffff); /* addiu t4,t4,-1 */
640 stl_raw(p++, 0x1580fffa); /* bnez t4,84c */
641 stl_raw(p++, 0x00000000); /* nop */
642 stl_raw(p++, 0x01a00008); /* jr t5 */
643 stl_raw(p++, 0x01602021); /* move a0,t3 */
644 /* 0x870 */
645 stl_raw(p++, 0x3c08b800); /* lui t0,0xb400 */
646 stl_raw(p++, 0x350803f8); /* ori t0,t0,0x3f8 */
647 stl_raw(p++, 0x91090005); /* lbu t1,5(t0) */
648 stl_raw(p++, 0x00000000); /* nop */
649 stl_raw(p++, 0x31290040); /* andi t1,t1,0x40 */
650 stl_raw(p++, 0x1120fffc); /* beqz t1,878 <outch+0x8> */
651 stl_raw(p++, 0x00000000); /* nop */
652 stl_raw(p++, 0x03e00008); /* jr ra */
653 stl_raw(p++, 0xa1040000); /* sb a0,0(t0) */
654
655 }
656
657 static void prom_set(uint32_t* prom_buf, int index, const char *string, ...)
658 {
659 va_list ap;
660 int32_t table_addr;
661
662 if (index >= ENVP_NB_ENTRIES)
663 return;
664
665 if (string == NULL) {
666 prom_buf[index] = 0;
667 return;
668 }
669
670 table_addr = sizeof(int32_t) * ENVP_NB_ENTRIES + index * ENVP_ENTRY_SIZE;
671 prom_buf[index] = tswap32(ENVP_ADDR + table_addr);
672
673 va_start(ap, string);
674 vsnprintf((char *)prom_buf + table_addr, ENVP_ENTRY_SIZE, string, ap);
675 va_end(ap);
676 }
677
678 /* Kernel */
679 static int64_t load_kernel (void)
680 {
681 int64_t kernel_entry, kernel_high;
682 long initrd_size;
683 ram_addr_t initrd_offset;
684 int big_endian;
685 uint32_t *prom_buf;
686 long prom_size;
687 int prom_index = 0;
688
689 #ifdef TARGET_WORDS_BIGENDIAN
690 big_endian = 1;
691 #else
692 big_endian = 0;
693 #endif
694
695 if (load_elf(loaderparams.kernel_filename, cpu_mips_kseg0_to_phys, NULL,
696 (uint64_t *)&kernel_entry, NULL, (uint64_t *)&kernel_high,
697 big_endian, ELF_MACHINE, 1) < 0) {
698 fprintf(stderr, "qemu: could not load kernel '%s'\n",
699 loaderparams.kernel_filename);
700 exit(1);
701 }
702
703 /* load initrd */
704 initrd_size = 0;
705 initrd_offset = 0;
706 if (loaderparams.initrd_filename) {
707 initrd_size = get_image_size (loaderparams.initrd_filename);
708 if (initrd_size > 0) {
709 initrd_offset = (kernel_high + ~TARGET_PAGE_MASK) & TARGET_PAGE_MASK;
710 if (initrd_offset + initrd_size > ram_size) {
711 fprintf(stderr,
712 "qemu: memory too small for initial ram disk '%s'\n",
713 loaderparams.initrd_filename);
714 exit(1);
715 }
716 initrd_size = load_image_targphys(loaderparams.initrd_filename,
717 initrd_offset,
718 ram_size - initrd_offset);
719 }
720 if (initrd_size == (target_ulong) -1) {
721 fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
722 loaderparams.initrd_filename);
723 exit(1);
724 }
725 }
726
727 /* Setup prom parameters. */
728 prom_size = ENVP_NB_ENTRIES * (sizeof(int32_t) + ENVP_ENTRY_SIZE);
729 prom_buf = qemu_malloc(prom_size);
730
731 prom_set(prom_buf, prom_index++, loaderparams.kernel_filename);
732 if (initrd_size > 0) {
733 prom_set(prom_buf, prom_index++, "rd_start=0x%" PRIx64 " rd_size=%li %s",
734 cpu_mips_phys_to_kseg0(NULL, initrd_offset), initrd_size,
735 loaderparams.kernel_cmdline);
736 } else {
737 prom_set(prom_buf, prom_index++, loaderparams.kernel_cmdline);
738 }
739
740 prom_set(prom_buf, prom_index++, "memsize");
741 prom_set(prom_buf, prom_index++, "%i", loaderparams.ram_size);
742 prom_set(prom_buf, prom_index++, "modetty0");
743 prom_set(prom_buf, prom_index++, "38400n8r");
744 prom_set(prom_buf, prom_index++, NULL);
745
746 rom_add_blob_fixed("prom", prom_buf, prom_size,
747 cpu_mips_kseg0_to_phys(NULL, ENVP_ADDR));
748
749 return kernel_entry;
750 }
751
752 static void main_cpu_reset(void *opaque)
753 {
754 CPUState *env = opaque;
755 cpu_reset(env);
756
757 /* The bootloader does not need to be rewritten as it is located in a
758 read only location. The kernel location and the arguments table
759 location does not change. */
760 if (loaderparams.kernel_filename) {
761 env->CP0_Status &= ~((1 << CP0St_BEV) | (1 << CP0St_ERL));
762 }
763 }
764
765 static void cpu_request_exit(void *opaque, int irq, int level)
766 {
767 CPUState *env = cpu_single_env;
768
769 if (env && level) {
770 cpu_exit(env);
771 }
772 }
773
774 static
775 void mips_malta_init (ram_addr_t ram_size,
776 const char *boot_device,
777 const char *kernel_filename, const char *kernel_cmdline,
778 const char *initrd_filename, const char *cpu_model)
779 {
780 char *filename;
781 ram_addr_t ram_offset;
782 ram_addr_t bios_offset;
783 target_long bios_size;
784 int64_t kernel_entry;
785 PCIBus *pci_bus;
786 ISADevice *isa_dev;
787 CPUState *env;
788 ISADevice *rtc_state;
789 FDCtrl *floppy_controller;
790 MaltaFPGAState *malta_fpga;
791 qemu_irq *i8259;
792 qemu_irq *cpu_exit_irq;
793 int piix4_devfn;
794 uint8_t *eeprom_buf;
795 i2c_bus *smbus;
796 int i;
797 DriveInfo *dinfo;
798 DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
799 DriveInfo *fd[MAX_FD];
800 int fl_idx = 0;
801 int fl_sectors = 0;
802 int be;
803
804 /* Make sure the first 3 serial ports are associated with a device. */
805 for(i = 0; i < 3; i++) {
806 if (!serial_hds[i]) {
807 char label[32];
808 snprintf(label, sizeof(label), "serial%d", i);
809 serial_hds[i] = qemu_chr_open(label, "null", NULL);
810 }
811 }
812
813 /* init CPUs */
814 if (cpu_model == NULL) {
815 #ifdef TARGET_MIPS64
816 cpu_model = "20Kc";
817 #else
818 cpu_model = "24Kf";
819 #endif
820 }
821 env = cpu_init(cpu_model);
822 if (!env) {
823 fprintf(stderr, "Unable to find CPU definition\n");
824 exit(1);
825 }
826 qemu_register_reset(main_cpu_reset, env);
827
828 /* allocate RAM */
829 if (ram_size > (256 << 20)) {
830 fprintf(stderr,
831 "qemu: Too much memory for this machine: %d MB, maximum 256 MB\n",
832 ((unsigned int)ram_size / (1 << 20)));
833 exit(1);
834 }
835 ram_offset = qemu_ram_alloc(NULL, "mips_malta.ram", ram_size);
836 bios_offset = qemu_ram_alloc(NULL, "mips_malta.bios", BIOS_SIZE);
837
838
839 cpu_register_physical_memory(0, ram_size, ram_offset | IO_MEM_RAM);
840
841 /* Map the bios at two physical locations, as on the real board. */
842 cpu_register_physical_memory(0x1e000000LL,
843 BIOS_SIZE, bios_offset | IO_MEM_ROM);
844 cpu_register_physical_memory(0x1fc00000LL,
845 BIOS_SIZE, bios_offset | IO_MEM_ROM);
846
847 #ifdef TARGET_WORDS_BIGENDIAN
848 be = 1;
849 #else
850 be = 0;
851 #endif
852 /* FPGA */
853 malta_fpga = malta_fpga_init(0x1f000000LL, env->irq[2], serial_hds[2]);
854
855 /* Load firmware in flash / BIOS unless we boot directly into a kernel. */
856 if (kernel_filename) {
857 /* Write a small bootloader to the flash location. */
858 loaderparams.ram_size = ram_size;
859 loaderparams.kernel_filename = kernel_filename;
860 loaderparams.kernel_cmdline = kernel_cmdline;
861 loaderparams.initrd_filename = initrd_filename;
862 kernel_entry = load_kernel();
863 write_bootloader(env, qemu_get_ram_ptr(bios_offset), kernel_entry);
864 } else {
865 dinfo = drive_get(IF_PFLASH, 0, fl_idx);
866 if (dinfo) {
867 /* Load firmware from flash. */
868 bios_size = 0x400000;
869 fl_sectors = bios_size >> 16;
870 #ifdef DEBUG_BOARD_INIT
871 printf("Register parallel flash %d size " TARGET_FMT_lx " at "
872 "offset %08lx addr %08llx '%s' %x\n",
873 fl_idx, bios_size, bios_offset, 0x1e000000LL,
874 bdrv_get_device_name(dinfo->bdrv), fl_sectors);
875 #endif
876 pflash_cfi01_register(0x1e000000LL, bios_offset,
877 dinfo->bdrv, 65536, fl_sectors,
878 4, 0x0000, 0x0000, 0x0000, 0x0000, be);
879 fl_idx++;
880 } else {
881 /* Load a BIOS image. */
882 if (bios_name == NULL)
883 bios_name = BIOS_FILENAME;
884 filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
885 if (filename) {
886 bios_size = load_image_targphys(filename, 0x1fc00000LL,
887 BIOS_SIZE);
888 qemu_free(filename);
889 } else {
890 bios_size = -1;
891 }
892 if ((bios_size < 0 || bios_size > BIOS_SIZE) && !kernel_filename) {
893 fprintf(stderr,
894 "qemu: Could not load MIPS bios '%s', and no -kernel argument was specified\n",
895 bios_name);
896 exit(1);
897 }
898 }
899 /* In little endian mode the 32bit words in the bios are swapped,
900 a neat trick which allows bi-endian firmware. */
901 #ifndef TARGET_WORDS_BIGENDIAN
902 {
903 uint32_t *addr = qemu_get_ram_ptr(bios_offset);;
904 uint32_t *end = addr + bios_size;
905 while (addr < end) {
906 bswap32s(addr);
907 }
908 }
909 #endif
910 }
911
912 /* Board ID = 0x420 (Malta Board with CoreLV)
913 XXX: theoretically 0x1e000010 should map to flash and 0x1fc00010 should
914 map to the board ID. */
915 stl_phys(0x1fc00010LL, 0x00000420);
916
917 /* Init internal devices */
918 cpu_mips_irq_init_cpu(env);
919 cpu_mips_clock_init(env);
920
921 /* Interrupt controller */
922 /* The 8259 is attached to the MIPS CPU INT0 pin, ie interrupt 2 */
923 i8259 = i8259_init(env->irq[2]);
924
925 /* Northbridge */
926 pci_bus = pci_gt64120_init(i8259);
927
928 /* Southbridge */
929
930 if (drive_get_max_bus(IF_IDE) >= MAX_IDE_BUS) {
931 fprintf(stderr, "qemu: too many IDE bus\n");
932 exit(1);
933 }
934
935 for(i = 0; i < MAX_IDE_BUS * MAX_IDE_DEVS; i++) {
936 hd[i] = drive_get(IF_IDE, i / MAX_IDE_DEVS, i % MAX_IDE_DEVS);
937 }
938
939 piix4_devfn = piix4_init(pci_bus, 80);
940 isa_bus_irqs(i8259);
941 pci_piix4_ide_init(pci_bus, hd, piix4_devfn + 1);
942 usb_uhci_piix4_init(pci_bus, piix4_devfn + 2);
943 smbus = piix4_pm_init(pci_bus, piix4_devfn + 3, 0x1100, isa_reserve_irq(9),
944 NULL, NULL, 0);
945 eeprom_buf = qemu_mallocz(8 * 256); /* XXX: make this persistent */
946 for (i = 0; i < 8; i++) {
947 /* TODO: Populate SPD eeprom data. */
948 DeviceState *eeprom;
949 eeprom = qdev_create((BusState *)smbus, "smbus-eeprom");
950 qdev_prop_set_uint8(eeprom, "address", 0x50 + i);
951 qdev_prop_set_ptr(eeprom, "data", eeprom_buf + (i * 256));
952 qdev_init_nofail(eeprom);
953 }
954 pit = pit_init(0x40, isa_reserve_irq(0));
955 cpu_exit_irq = qemu_allocate_irqs(cpu_request_exit, NULL, 1);
956 DMA_init(0, cpu_exit_irq);
957
958 /* Super I/O */
959 isa_dev = isa_create_simple("i8042");
960
961 rtc_state = rtc_init(2000, NULL);
962 serial_isa_init(0, serial_hds[0]);
963 serial_isa_init(1, serial_hds[1]);
964 if (parallel_hds[0])
965 parallel_init(0, parallel_hds[0]);
966 for(i = 0; i < MAX_FD; i++) {
967 fd[i] = drive_get(IF_FLOPPY, 0, i);
968 }
969 floppy_controller = fdctrl_init_isa(fd);
970
971 /* Sound card */
972 audio_init(pci_bus);
973
974 /* Network card */
975 network_init();
976
977 /* Optional PCI video card */
978 if (cirrus_vga_enabled) {
979 pci_cirrus_vga_init(pci_bus);
980 } else if (vmsvga_enabled) {
981 pci_vmsvga_init(pci_bus);
982 } else if (std_vga_enabled) {
983 pci_vga_init(pci_bus, 0, 0);
984 }
985 }
986
987 static QEMUMachine mips_malta_machine = {
988 .name = "malta",
989 .desc = "MIPS Malta Core LV",
990 .init = mips_malta_init,
991 .is_default = 1,
992 };
993
994 static void mips_malta_machine_init(void)
995 {
996 qemu_register_machine(&mips_malta_machine);
997 }
998
999 machine_init(mips_malta_machine_init);
Qemu copy for testing