Qemu: qemu_glofiish.diff

Makefile.target

@@ -655 +655 @@
 OBJS+= framebuffer.o
 OBJS+= s3c2410.o s3c24xx_gpio.o s3c24xx_lcd.o s3c24xx_mmci.o s3c24xx_rtc.o s3c24xx_udc.o s3c2410_nand.o s3c2440_nand.o  
 OBJS+= dm9000.o eeprom24c0x.o
+OBJS+= glofiish.o
 OBJS+= mini2440.o
 OBJS+= syborg.o syborg_fb.o syborg_interrupt.o syborg_keyboard.o
 OBJS+= syborg_serial.o syborg_timer.o syborg_pointer.o syborg_rtc.o

hw/boards.h

@@ -131 +131 @@
 /* mini2440.c */
 extern QEMUMachine mini2440_machine;
 
+/* glofiish.c */
+extern QEMUMachine glofiish_machine;
+
 /* syborg.c */
 extern QEMUMachine syborg_machine;
 

(a) /dev/null vs. (b) b/hw/glofiish.c

@@ +1 @@
+/*
+ * E-Ten Glofiish smartphone M800 / X800
+ *
+ * This code is licensed under the GNU GPL v2.
+ */
+
+#include "hw.h"
+#include "s3c.h"
+#include "arm-misc.h"
+#include "sysemu.h"
+#include "i2c.h"
+#include "qemu-timer.h"
+#include "devices.h"
+#include "audio/audio.h"
+#include "boards.h"
+#include "console.h"
+#include "usb.h"
+#include "net.h"
+#include "sd.h"
+#include "dm9000.h"
+#include "eeprom24c0x.h"
+
+#define GLOFIISH_GPIO_SD_DETECT S3C_GPG(7)
+//#define GLOFIISH_GPIO_WP_SD                   S3C_GPH(??)
+#define GLOFIISH_IRQ_SD_DETECT          S3C_EINT(15)
+
+struct glofiish_s {
+    struct s3c_state_s *cpu;
+    unsigned int ram;
+    const char * kernel;
+    SDState * mmc;
+    NANDFlashState *nand;
+};
+
+
+static void glofiish_gpio_setup(struct glofiish_s *s)
+{
+
+    /* Register the SD card pins to the lower SD driver */
+        sd_set_cb(s->mmc,
+                        0, //s3c_gpio_in_get(s->cpu->io)[MINI2440_GPIO_WP_SD],
+                        s3c_gpio_in_get(s->cpu->io)[GLOFIISH_IRQ_SD_DETECT]);
+
+        s3c_gpio_set_dat(s->cpu->io, S3C_GPG(7), 1);
+
+}
+
+static int glofiish_load_from_nand(NANDFlashState *nand,
+                uint32_t nand_offset, uint32_t s3c_base_offset, uint32_t size)
+{
+        uint8_t buffer[512];
+        uint32_t src = 0;
+        int page = 0;
+        uint32_t dst = 0;
+
+        if (!nand)
+                return 0;
+
+        for (page = 0; page < (size / 512); page++, src += 512, dst += 512) {
+
+                fprintf(stderr, "src: %d, dst: %d\n", src, dst);
+
+                if (nand_readraw(nand, nand_offset + src, buffer, 512)) {
+                        cpu_physical_memory_write(s3c_base_offset + dst, buffer, 512);
+                } else {
+                        fprintf(stderr, "%s: failed to load nand %d:%d\n", __FUNCTION__,
+                                nand_offset + src, 512 + 16);
+                        return 0;
+                }
+        }
+        return (int) size;
+}
+
+static void glofiish_reset(void *opaque)
+{
+    struct glofiish_s *s = (struct glofiish_s *) opaque;
+//    uint32_t image_size;
+
+        /*
+         * Normally we would load 4 KB of nand to SRAM and jump there, but
+         * it is not working perfectly as expected, so we cheat and load
+         * it from nand directly relocated to 0x33f80000 and jump there
+         */
+#if 0
+        if (mini2440_load_from_nand(s->nand, 0, S3C_RAM_BASE | 0x03f80000, 256*1024)> 0) {
+                fprintf(stderr, "%s: loaded default u-boot from NAND\n", __FUNCTION__);
+                s->cpu->env->regs[15] = S3C_RAM_BASE | 0x03f80000; /* start address, u-boot already relocated */
+        }
+#endif
+
+        if (glofiish_load_from_nand(s->nand, 0, S3C_SRAM_BASE_NANDBOOT, S3C_SRAM_SIZE) > 0) {
+            s->cpu->env->regs[15] = S3C_SRAM_BASE_NANDBOOT;     /* start address, u-boot relocating code */
+            fprintf(stderr, "%s: 4KB SteppingStone loaded from NAND\n", __FUNCTION__);
+        }
+        fprintf(stderr, "%d %d\n", S3C_SRAM_BASE_NANDBOOT, S3C_SRAM_SIZE);
+#if 0
+        /*
+         * if a u--boot is available as a file, we always use it
+         */
+        {
+            image_size = load_image("mini2440/u-boot.bin", phys_ram_base + 0x03f80000);
+            if (image_size < 0)
+                    image_size = load_image("u-boot.bin", phys_ram_base + 0x03f80000);
+                if (image_size > 0) {
+                        if (image_size & (512 -1))      /* round size to a NAND block size */
+                                image_size = (image_size + 512) & ~(512-1);
+                fprintf(stderr, "%s: loaded override u-boot (size %x)\n", __FUNCTION__, image_size);
+                    s->cpu->env->regs[15] = S3C_RAM_BASE | 0x03f80000;  /* start address, u-boot already relocated */
+                }
+        }
+        /*
+         * if a kernel was explicitly specified, we load it too
+         */
+        if (s->kernel) {
+                image_size = load_image(s->kernel, phys_ram_base + 0x02000000);
+                if (image_size > 0) {
+                        if (image_size & (512 -1))      /* round size to a NAND block size */
+                                image_size = (image_size + 512) & ~(512-1);
+                fprintf(stderr, "%s: loaded %s (size %x)\n", __FUNCTION__, s->kernel, image_size);
+            }
+        }
+#endif
+}
+
+/* Board init.  */
+static struct glofiish_s *glofiish_init_common(int ram_size,
+                const char *kernel_filename, const char *cpu_model,
+                SDState *mmc)
+{
+    struct glofiish_s *s = (struct glofiish_s *)
+            qemu_mallocz(sizeof(struct glofiish_s));
+
+    s->ram = 0x04000000;
+    s->kernel = kernel_filename;
+    s->mmc = mmc;
+
+    /* Setup CPU & memory */
+    if (ram_size < s->ram + S3C_SRAM_SIZE) {
+        fprintf(stderr, "This platform requires %i bytes of memory (not %d)\n",
+                        s->ram + S3C_SRAM_SIZE, ram_size);
+        exit(1);
+    }
+    if (cpu_model && strcmp(cpu_model, "arm920t")) {
+        fprintf(stderr, "This platform requires an ARM920T core\n");
+        exit(2);
+    }
+    s->cpu = s3c24xx_init(S3C_CPU_2440, 12000000 /* 12 mhz */, s->ram, S3C_SRAM_BASE_NANDBOOT, s->mmc);
+
+    /* Setup peripherals */
+    glofiish_gpio_setup(s);
+
+    /* Setup initial (reset) machine state */
+    qemu_register_reset(glofiish_reset, s);
+
+    return s;
+}
+
+static void glofiish_init(ram_addr_t ram_size,
+                const char *boot_device,
+                const char *kernel_filename, const char *kernel_cmdline,
+                const char *initrd_filename, const char *cpu_model)
+{
+    struct glofiish_s *glofiish;
+    int sd_idx = drive_get_index(IF_SD, 0, 0);
+    SDState *sd = 0;
+
+    if (sd_idx >= 0)
+        sd = sd_init(drives_table[sd_idx].bdrv, 1);
+
+    glofiish = glofiish_init_common(ram_size,
+                    kernel_filename, cpu_model, sd);
+
+        glofiish->nand = nand_init(NAND_MFR_SAMSUNG, 0xaa);
+    glofiish->cpu->nand->reg(glofiish->cpu->nand, glofiish->nand);
+
+    glofiish_reset(glofiish);
+}
+
+QEMUMachine glofiish_machine = {
+    "glofiish",
+    "E-Ten glofiish smartphone M800/X800 (S3C2442A)",
+    .init = glofiish_init,
+};
+

hw/nand.c

@@ -357 +357 @@
 
 void nand_getpins(NANDFlashState *s, int *rb)
 {
-    *rb = 1;
+    *rb = 5; //1;
 }
 
 void nand_setio(NANDFlashState *s, uint8_t value)

hw/sd.c

@@ -33 +33 @@
 #include "block.h"
 #include "sd.h"
 
-//#define DEBUG_SD 1
+#define DEBUG_SD 1
 
 #ifdef DEBUG_SD
 #define DPRINTF(fmt, ...) \

target-arm/machine.c

@@ -24 +24 @@
     qemu_register_machine(&musicpal_machine);
     qemu_register_machine(&tosapda_machine);
     qemu_register_machine(&mini2440_machine);
+    qemu_register_machine(&glofiish_machine);
     qemu_register_machine(&syborg_machine);
 }