Archipelago » qemu

}

ram_addr_t cpu_get_physical_page_desc(target_phys_addr_t addr);

void qemu_ram_free(ram_addr_t addr);

/* This should only be used for ram local to a device.  */

void *qemu_get_ram_ptr(ram_addr_t addr);

    return last;

}

{

    RAMBlock *new_block;

    /* DRAM at address zero */

    cpu_register_physical_memory(0, ram_size,

    /* Internal SRAM.  */

    cpu_register_physical_memory(AN5206_RAMBAR_ADDR, 512,

    mcf5206_init(AN5206_MBAR_ADDR, env);

    /* Flash programming is done via the SCU, so pretend it is ROM.  */

    cpu_register_physical_memory(0, flash_size,

    cpu_register_physical_memory(0x20000000, sram_size,

    armv7m_bitband_init();

    nvic = qdev_create(NULL, "armv7m_nvic");

       space.  This stops qemu complaining about executing code outside RAM

       when returning from an exception.  */

    cpu_register_physical_memory(0xfffff000, 0x1000,

    qemu_register_reset(armv7m_reset, env);

    return pic;

    env = cpu_init(cpu_model);

    /* allocate RAM */

    cpu_register_physical_memory(0x40000000, ram_size, phys_ram | IO_MEM_RAM);

    /* The ETRAX-FS has 128Kb on chip ram, the docs refer to it as the 

       internal memory.  */

    cpu_register_physical_memory(0x38000000, INTMEM_SIZE,

                                 phys_intmem | IO_MEM_RAM);

    /* RAM at address zero */

    cpu_register_physical_memory(0, ram_size,

    /* Load kernel.  */

    if (kernel_filename) {

    env = cpu_init(cpu_model);

    /* allocate RAM */

    cpu_register_physical_memory(0x40000000, ram_size, phys_ram | IO_MEM_RAM);

    /* The ETRAX-FS has 128Kb on chip ram, the docs refer to it as the 

       internal memory.  */

    cpu_register_physical_memory(0x38000000, INTMEM_SIZE,

                                 phys_intmem | IO_MEM_RAM);

    dinfo = drive_get(IF_PFLASH, 0, 0);

    pflash_cfi02_register(0x0, phys_flash,

                          dinfo ? dinfo->bdrv : NULL, (64 * 1024),

    s = qemu_mallocz(sizeof(G364State));

    s->vram_size = 8 * 1024 * 1024;

    s->vram = qemu_get_ram_ptr(s->vram_offset);

    s->irq = irq;

#else

    be = 0;

#endif

                               dinfo->bdrv, sector_len, connex_rom / sector_len,

                               2, 0, 0, 0, 0, be)) {

        fprintf(stderr, "qemu: Error registering flash memory.\n");

#else

    be = 0;

#endif

                               dinfo->bdrv, sector_len, verdex_rom / sector_len,

                               2, 0, 0, 0, 0, be)) {

        fprintf(stderr, "qemu: Error registering flash memory.\n");

    pci_register_bar((PCIDevice *)d, 4, 0x10,

                           PCI_BASE_ADDRESS_SPACE_IO, bmdma_map);

    ide_bus_new(&d->bus[0], &d->dev.qdev);

    ide_bus_new(&d->bus[1], &d->dev.qdev);

    }

    memcpy(integrator_spd + 73, "QEMU-MEMORY", 11);

    s->cm_init = 0x00000112;

    iomemtype = cpu_register_io_memory(integratorcm_readfn,

                                       integratorcm_writefn, s);

        fprintf(stderr, "Unable to find CPU definition\n");

        exit(1);

    }

    /* ??? On a real system the first 1Mb is mapped as SSRAM or boot flash.  */

    /* ??? RAM should repeat to fill physical memory space.  */

    /* SDRAM at address zero*/

    /* Setup CPU & memory */

    cpu = pxa270_init(mainstone_binfo.ram_size, cpu_model);

    cpu_register_physical_memory(0, MAINSTONE_ROM,

#ifdef TARGET_WORDS_BIGENDIAN

    be = 1;

        }

        if (!pflash_cfi01_register(mainstone_flash_base[i],

                                   dinfo->bdrv, sector_len,

                                   MAINSTONE_FLASH / sector_len, 4, 0, 0, 0, 0,

                                   be)) {

    /* DRAM at 0x40000000 */

    cpu_register_physical_memory(0x40000000, ram_size,

    /* Internal SRAM.  */

    cpu_register_physical_memory(0x80000000, 16384,

    /* Internal peripherals.  */

    pic = mcf_intc_init(0xfc048000, env);

    bios_size = 1024 * 1024;

    /* allocate RAM */

    cpu_register_physical_memory(0, ram_size, IO_MEM_RAM);

    cpu_register_physical_memory(0x1fc00000LL,

    qemu_register_reset(main_cpu_reset, env);

    /* allocate RAM */

    cpu_register_physical_memory(0, ram_size, ram_offset | IO_MEM_RAM);

    cpu_register_physical_memory(0x1fc00000LL,

                                 MAGNUM_BIOS_SIZE, bios_offset | IO_MEM_ROM);

    cpu_register_physical_memory(0xfff00000LL,

                ((unsigned int)ram_size / (1 << 20)));

        exit(1);

    }

    cpu_register_physical_memory(0, ram_size, ram_offset | IO_MEM_RAM);

    qemu_register_reset(main_cpu_reset, reset_info);

    /* Allocate RAM. */

    cpu_register_physical_memory(0, ram_size, ram_offset | IO_MEM_RAM);

                ((unsigned int)ram_size / (1 << 20)));

        exit(1);

    }

    cpu_register_physical_memory(0, ram_size, ram_offset | IO_MEM_RAM);

    be = 0;

#endif

    if ((bios_size > 0) && (bios_size <= BIOS_SIZE)) {

	cpu_register_physical_memory(0x1fc00000, BIOS_SIZE,

                                     bios_offset | IO_MEM_ROM);

        load_image_targphys(filename, 0x1fc00000, BIOS_SIZE);

    } else if ((dinfo = drive_get(IF_PFLASH, 0, 0)) != NULL) {

        uint32_t mips_rom = 0x00400000;

        if (!pflash_cfi01_register(0x1fc00000, bios_offset,

                                   dinfo->bdrv, sector_len,

                                   mips_rom / sector_len,

    /* For now we use a fixed - the original - RAM size */

    cpu_register_physical_memory(0, MP_RAM_DEFAULT_SIZE,

    cpu_register_physical_memory(MP_SRAM_BASE, MP_SRAM_SIZE, sram_off);

    dev = sysbus_create_simple("mv88w8618_pic", MP_PIC_BASE,

         * image is smaller than 32 MB.

         */

#ifdef TARGET_WORDS_BIGENDIAN

                              dinfo->bdrv, 0x10000,

                              (flash_size + 0xffff) >> 16,

                              MP_FLASH_SIZE_MAX / flash_size,

                              2, 0x00BF, 0x236D, 0x0000, 0x0000,

                              0x5555, 0x2AAA, 1);

#else

                              dinfo->bdrv, 0x10000,

                              (flash_size + 0xffff) >> 16,

                              MP_FLASH_SIZE_MAX / flash_size,

    /* Memory-mapped stuff */

    cpu_register_physical_memory(OMAP_EMIFF_BASE, s->sdram_size,

    cpu_register_physical_memory(OMAP_IMIF_BASE, s->sram_size,

    omap_clkm_init(0xfffece00, 0xe1008000, s);

    /* Memory-mapped stuff */

    cpu_register_physical_memory(OMAP2_Q2_BASE, s->sdram_size,

    cpu_register_physical_memory(OMAP2_SRAM_BASE, s->sram_size,

    s->l4 = omap_l4_init(OMAP2_L4_BASE, 54);

    /* External Flash (EMIFS) */

    cpu_register_physical_memory(OMAP_CS0_BASE, flash_size,

    io = cpu_register_io_memory(static_readfn, static_writefn, &cs0val);

    cpu_register_physical_memory(OMAP_CS0_BASE + flash_size,

#endif

    if ((dinfo = drive_get(IF_PFLASH, 0, fl_idx)) != NULL) {

                                   dinfo->bdrv, sector_size,

                                   flash_size / sector_size,

                                   4, 0, 0, 0, 0, be)) {

    if ((version == 1) &&

            (dinfo = drive_get(IF_PFLASH, 0, fl_idx)) != NULL) {

        cpu_register_physical_memory(OMAP_CS1_BASE, flash1_size,

        io = cpu_register_io_memory(static_readfn, static_writefn, &cs1val);

        cpu_register_physical_memory(OMAP_CS1_BASE + flash1_size,

                        OMAP_CS1_SIZE - flash1_size, io);

                                   dinfo->bdrv, sector_size,

                                   flash1_size / sector_size,

                                   4, 0, 0, 0, 0, be)) {

        s->bdrv = dinfo->bdrv;

    s->otp = memset(qemu_malloc((64 + 2) << PAGE_SHIFT),

                    0xff, (64 + 2) << PAGE_SHIFT);

    ram = qemu_get_ram_ptr(s->ram);

    s->boot[0] = ram + (0x0000 << s->shift);

    s->boot[1] = ram + (0x8000 << s->shift);

    /* External Flash (EMIFS) */

    cpu_register_physical_memory(OMAP_CS0_BASE, flash_size,

    io = cpu_register_io_memory(static_readfn, static_writefn, &cs0val);

    cpu_register_physical_memory(OMAP_CS0_BASE + flash_size,

    linux_boot = (kernel_filename != NULL);

    /* allocate RAM */

    cpu_register_physical_memory(0, 0xa0000, ram_addr);

    cpu_register_physical_memory(0x100000,

                 below_4g_mem_size - 0x100000,

        (bios_size % 65536) != 0) {

        goto bios_error;

    }

    ret = rom_add_file_fixed(bios_name, (uint32_t)(-bios_size));

    if (ret != 0) {

    bios_error:

                                 isa_bios_size,

                                 (bios_offset + bios_size - isa_bios_size) | IO_MEM_ROM);

    cpu_register_physical_memory(PC_ROM_MIN_VGA, PC_ROM_SIZE, option_rom_offset);

    /* map all the bios at the top of memory */

    int size;

    char *path;

    void *ptr;

    if (!pdev->romfile)

        return 0;

        size = 1 << qemu_fls(size);

    }

    ptr = qemu_get_ram_ptr(pdev->rom_offset);

    load_image(path, ptr);

    qemu_register_reset(main_cpu_reset, env);

    /* Attach emulated BRAM through the LMB.  */

    cpu_register_physical_memory(0x00000000, LMB_BRAM_SIZE,

                                 phys_lmb_bram | IO_MEM_RAM);

    cpu_register_physical_memory(ddr_base, ram_size, phys_ram | IO_MEM_RAM);

    dinfo = drive_get(IF_PFLASH, 0, 0);

    pflash_cfi01_register(0xa0000000, phys_flash,

                          dinfo ? dinfo->bdrv : NULL, (64 * 1024),

    DriveInfo *dinfo;

    /* XXX: fix this */

    ram_sizes[0] = 0x08000000;

    ram_bases[1] = 0x00000000;

    ram_sizes[1] = 0x00000000;

                        kernel_filename == NULL ? 0 : 1);

    /* allocate SRAM */

    sram_size = 512 * 1024;

#ifdef DEBUG_BOARD_INIT

    printf("%s: register SRAM at offset %08lx\n", __func__, sram_offset);

#endif

    dinfo = drive_get(IF_PFLASH, 0, fl_idx);

    if (dinfo) {

        bios_size = bdrv_getlength(dinfo->bdrv);

        fl_sectors = (bios_size + 65535) >> 16;

#ifdef DEBUG_BOARD_INIT

        printf("Register parallel flash %d size " TARGET_FMT_lx

#ifdef DEBUG_BOARD_INIT

        printf("Load BIOS from file\n");

#endif

        if (bios_name == NULL)

            bios_name = BIOS_FILENAME;

        filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);

    DriveInfo *dinfo;

    /* RAM is soldered to the board so the size cannot be changed */

    ram_sizes[0] = 0x04000000;

    ram_sizes[1] = 0x04000000;

    ram_size = 0x08000000;

#ifdef DEBUG_BOARD_INIT

        /* XXX: should check that size is 2MB */

        //        bios_size = 2 * 1024 * 1024;

        fl_sectors = (bios_size + 65535) >> 16;

#ifdef DEBUG_BOARD_INIT

        printf("Register parallel flash %d size " TARGET_FMT_lx

               " at offset %08lx addr " TARGET_FMT_lx " '%s' %d\n",

#endif

        if (bios_name == NULL)

            bios_name = BIOS_FILENAME;

        filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);

        if (filename) {

            bios_size = load_image(filename, qemu_get_ram_ptr(bios_offset));

               fl_idx, bios_size, bios_offset, (target_ulong)0xfc000000,

               bdrv_get_device_name(dinfo->bdrv));

#endif

        pflash_cfi02_register(0xfc000000, bios_offset,

                              dinfo->bdrv, 65536, fl_sectors, 1,

                              4, 0x0001, 0x22DA, 0x0000, 0x0000, 0x555, 0x2AA,

    ppc405_ocm_t *ocm;

    ocm = qemu_mallocz(sizeof(ppc405_ocm_t));

    qemu_register_reset(&ocm_reset, ocm);

    ppc_dcr_register(env, OCM0_ISARC,

                     ocm, &dcr_read_ocm, &dcr_write_ocm);

            unsigned int bank_size = sdram_bank_sizes[j];

            if (bank_size <= size_left) {

                ram_sizes[i] = bank_size;

                size_left -= bank_size;

                break;

    }

    /* allocate RAM */

    cpu_register_physical_memory(0, ram_size, ram_offset);

    /* allocate and load BIOS */

    if (bios_name == NULL)

        bios_name = PROM_FILENAME;

    filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);

    }

    /* allocate and load VGA BIOS */

    vga_bios_ptr = qemu_get_ram_ptr(vga_bios_offset);

    filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, VGABIOS_FILENAME);

    if (filename) {

        exit(1);

    }

    cpu_register_physical_memory(0, ram_size, ram_offset);

    /* allocate and load BIOS */

    if (bios_name == NULL)

        bios_name = PROM_FILENAME;

    filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);

    }

    /* allocate and load VGA BIOS */

    vga_bios_ptr = qemu_get_ram_ptr(vga_bios_offset);

    filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, VGABIOS_FILENAME);

    if (filename) {

    }

    /* allocate RAM */

    cpu_register_physical_memory(0, ram_size, ram_offset);

    /* allocate and load BIOS */

    if (bios_name == NULL)

        bios_name = BIOS_FILENAME;

    filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);

    ram_size &= ~(RAM_SIZES_ALIGN - 1);

    /* Register Memory */

    /* MPIC */

    irqs = qemu_mallocz(sizeof(qemu_irq) * OPENPIC_OUTPUT_NB);

    /* SDRAM & Internal Memory Storage */

    cpu_register_physical_memory(PXA2XX_SDRAM_BASE,

    cpu_register_physical_memory(PXA2XX_INTERNAL_BASE,

    s->pic = pxa2xx_pic_init(0x40d00000, s->env);

    /* SDRAM & Internal Memory Storage */

    cpu_register_physical_memory(PXA2XX_SDRAM_BASE, sdram_size,

    cpu_register_physical_memory(PXA2XX_INTERNAL_BASE, PXA2XX_INTERNAL_SIZE,

    s->pic = pxa2xx_pic_init(0x40d00000, s->env);

    }

    /* Allocate memory space */

    cpu_register_physical_memory(SDRAM_BASE, SDRAM_SIZE, sdram_addr);

    /* Register peripherals */

    s = sh7750_init(env);

    /* onboard flash memory */

    dinfo = drive_get(IF_PFLASH, 0, 0);

                          dinfo ? dinfo->bdrv : NULL, (16 * 1024),

                          FLASH_SIZE >> 16,

                          1, 4, 0x0000, 0x0000, 0x0000, 0x0000,

        /* Core tile RAM.  */

        low_ram_size = ram_size - 0x20000000;

        ram_size = 0x20000000;

        cpu_register_physical_memory(0x20000000, low_ram_size,

                                     ram_offset | IO_MEM_RAM);

    }

    low_ram_size = ram_size;

    if (low_ram_size > 0x10000000)

      low_ram_size = 0x10000000;

       startup code.  I guess this works on real hardware because the

       BootROM happens to be in ROM/flash or in memory that isn't clobbered

       until after Linux boots the secondary CPUs.  */

    cpu_register_physical_memory(SMP_BOOT_ADDR, 0x1000,

                                 ram_offset | IO_MEM_RAM);

    s390_bus = s390_virtio_bus_init(&ram_size);

    /* allocate RAM */

    cpu_register_physical_memory(0, ram_size, ram_addr);

    /* init CPUs */

    s->dc_crt_control = 0x00010000;

    /* allocate local memory */

    s->local_mem = qemu_get_ram_ptr(s->local_mem_offset);

    cpu_register_physical_memory(base, local_mem_bytes, s->local_mem_offset);

    sl_flash_register(cpu, (model == spitz) ? FLASH_128M : FLASH_1024M);

    cpu_register_physical_memory(0, SPITZ_ROM,

    /* Setup peripherals */

    spitz_keyboard_register(cpu);

{

    ram_addr_t idreg_offset;

    sysbus_init_mmio(dev, sizeof(idreg_data), idreg_offset | IO_MEM_ROM);

    return 0;

}

{

    ram_addr_t afx_offset;

    sysbus_init_mmio(dev, 4, afx_offset | IO_MEM_RAM);

    return 0;

}

{

    ram_addr_t prom_offset;

    sysbus_init_mmio(dev, PROM_SIZE_MAX, prom_offset | IO_MEM_ROM);

    return 0;

}

    RAM_size = d->size;

    sysbus_init_mmio(dev, RAM_size, ram_offset);

    return 0;

}

{

    ram_addr_t prom_offset;

    sysbus_init_mmio(dev, PROM_SIZE_MAX, prom_offset | IO_MEM_ROM);

    return 0;

}

    RAM_size = d->size;

    sysbus_init_mmio(dev, RAM_size, ram_offset);

    return 0;

}

    }

    /* RAM at address zero. */

    cpu_register_physical_memory(0, ram_size, ram_addr | IO_MEM_RAM);

    cpu_pic = arm_pic_init_cpu(env);

                    tc6393xb_writefn, s);

    cpu_register_physical_memory(base, 0x10000, iomemtype);

    s->vram_ptr = qemu_get_ram_ptr(s->vram_addr);

    cpu_register_physical_memory(base + 0x100000, 0x100000, s->vram_addr);

    s->scr_width = 480;

    int size;

    uint8_t *vram_base;

    vram_base = qemu_get_ram_ptr(vram_offset);

    s->vram_offset = vram_offset;

    cpu = pxa255_init(tosa_binfo.ram_size);

    cpu_register_physical_memory(0, TOSA_ROM,

    tmio = tc6393xb_init(0x10000000,

            pxa2xx_gpio_in_get(cpu->gpio)[TOSA_GPIO_TC6393XB_INT]);

        fprintf(stderr, "Unable to find CPU definition\n");

        exit(1);

    }

    /* ??? RAM should repeat to fill physical memory space.  */

    /* SDRAM at address zero.  */

    cpu_register_physical_memory(0, ram_size, ram_offset | IO_MEM_RAM);

#else

    s->is_vbe_vmstate = 0;

#endif

    s->vram_ptr = qemu_get_ram_ptr(s->vram_offset);

    s->vram_size = vga_ram_size;

    s->get_bpp = vga_get_bpp;

    s->fifo_size = SVGA_FIFO_SIZE;

    s->fifo_ptr = qemu_get_ram_ptr(s->fifo_offset);

    vga_common_init(&s->vga, vga_ram_size);