1570 lines
49 KiB
JavaScript
1570 lines
49 KiB
JavaScript
/*-------------------------------------------------------------------------
|
|
| SAE - Scripted Amiga Emulator
|
|
| https://github.com/naTmeg/ScriptedAmigaEmulator
|
|
|
|
|
| Copyright (C) 2012-2016 Rupert Hausberger
|
|
|
|
|
| This program is free software; you can redistribute it and/or
|
|
| modify it under the terms of the GNU General Public License
|
|
| as published by the Free Software Foundation; either version 2
|
|
| of the License, or (at your option) any later version.
|
|
|
|
|
| This program is distributed in the hope that it will be useful,
|
|
| but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
| GNU General Public License for more details.
|
|
|
|
|
| Note: ported from WinUAE 3.2.x
|
|
-------------------------------------------------------------------------*/
|
|
/* global references */
|
|
|
|
var SAER_Expansion_expamem_bank = null;
|
|
var SAER_Expansion_z3fastmem_bank = null;
|
|
|
|
/*---------------------------------*/
|
|
|
|
function SAEO_Expansion() {
|
|
const BOARD_AUTOCONFIG_Z2 = 2;
|
|
const BOARD_AUTOCONFIG_Z3 = 3;
|
|
const BOARD_NONAUTOCONFIG_BEFORE = 4;
|
|
const BOARD_NONAUTOCONFIG_AFTER_Z2 = 5;
|
|
const BOARD_NONAUTOCONFIG_AFTER_Z3 = 6;
|
|
const BOARD_IGNORE = 7;
|
|
|
|
const MAX_EXPANSION_BOARD_SPACE = 16;
|
|
//const KS12_BOOT_HACK = 1;
|
|
//const EXP_DEBUG = 0;
|
|
|
|
/*---------------------------------*/
|
|
/* 00 / 02 */
|
|
/* er_Type */
|
|
|
|
const Z2_MEM_8MB = 0x00; /* Size of Memory Block */
|
|
const Z2_MEM_4MB = 0x07;
|
|
const Z2_MEM_2MB = 0x06;
|
|
const Z2_MEM_1MB = 0x05;
|
|
const Z2_MEM_512KB = 0x04;
|
|
const Z2_MEM_256KB = 0x03;
|
|
const Z2_MEM_128KB = 0x02;
|
|
const Z2_MEM_64KB = 0x01;
|
|
/* extended definitions */
|
|
const Z3_MEM_16MB = 0x00;
|
|
const Z3_MEM_32MB = 0x01;
|
|
const Z3_MEM_64MB = 0x02;
|
|
const Z3_MEM_128MB = 0x03;
|
|
const Z3_MEM_256MB = 0x04;
|
|
const Z3_MEM_512MB = 0x05;
|
|
const Z3_MEM_1GB = 0x06;
|
|
|
|
const chainedconfig = 0x08; /* Next config is part of the same card */
|
|
const rom_card = 0x10; /* ROM vector is valid */
|
|
const add_memory = 0x20; /* Link RAM into free memory list */
|
|
|
|
/* Type of Expansion Card */
|
|
const protoautoconfig = 0x40;
|
|
const zorroII = 0xc0;
|
|
const zorroIII = 0x80;
|
|
|
|
/*---------------------------------*/
|
|
/* 04 - 06 & 10-16 */
|
|
|
|
/* Manufacturer */
|
|
const commodore_g = 513; /* Commodore Braunschweig (Germany) */
|
|
const commodore = 514; /* Commodore West Chester */
|
|
const gvp = 2017; /* GVP */
|
|
const ass = 2102; /* Advanced Systems & Software */
|
|
const hackers_id = 2011; /* Special ID for test cards */
|
|
|
|
/* Card Type */
|
|
const commodore_a2091 = 3; /* A2091 / A590 Card from C= */
|
|
const commodore_a2091_ram = 10; /* A2091 / A590 Ram on HD-Card */
|
|
const commodore_a2232 = 70; /* A2232 Multiport Expansion */
|
|
const ass_nexus_scsi = 1; /* Nexus SCSI Controller */
|
|
|
|
const gvp_series_2_scsi = 11;
|
|
const gvp_iv_24_gfx = 32;
|
|
|
|
/*---------------------------------*/
|
|
/* 08 - 0A */
|
|
/* er_Flags */
|
|
|
|
const Z3_SS_MEM_SAME = 0x00;
|
|
const Z3_SS_MEM_AUTO = 0x01;
|
|
const Z3_SS_MEM_64KB = 0x02;
|
|
const Z3_SS_MEM_128KB = 0x03;
|
|
const Z3_SS_MEM_256KB = 0x04;
|
|
const Z3_SS_MEM_512KB = 0x05;
|
|
const Z3_SS_MEM_1MB = 0x06; /* Zorro III card subsize */
|
|
const Z3_SS_MEM_2MB = 0x07;
|
|
const Z3_SS_MEM_4MB = 0x08;
|
|
const Z3_SS_MEM_6MB = 0x09;
|
|
const Z3_SS_MEM_8MB = 0x0a;
|
|
const Z3_SS_MEM_10MB = 0x0b;
|
|
const Z3_SS_MEM_12MB = 0x0c;
|
|
const Z3_SS_MEM_14MB = 0x0d;
|
|
const Z3_SS_MEM_defunct1 = 0x0e;
|
|
const Z3_SS_MEM_defunct2 = 0x0f;
|
|
|
|
const force_z3 = 0x10; /* *MUST* be set if card is Z3 */
|
|
const ext_size = 0x20; /* Use extended size table for bits 0-2 of er_Type */
|
|
const no_shutup = 0x40; /* Card cannot receive Shut_up_forever */
|
|
const care_addr = 0x80; /* Z2=Adress HAS to be $200000-$9fffff Z3=1->mem,0=io */
|
|
|
|
/*---------------------------------*/
|
|
/* 40-42 */
|
|
/* ec_interrupt (unused) */
|
|
|
|
const enable_irq = 0x01; /* enable Interrupt */
|
|
const reset_card = 0x04; /* Reset of Expansion Card - must be 0 */
|
|
const card_int2 = 0x10; /* READ ONLY: IRQ 2 active */
|
|
const card_irq6 = 0x20; /* READ ONLY: IRQ 6 active */
|
|
const card_irq7 = 0x40; /* READ ONLY: IRQ 7 active */
|
|
const does_irq = 0x80; /* READ ONLY: Card currently throws IRQ */
|
|
|
|
/*---------------------------------*/
|
|
/* ROM defines (DiagVec) */
|
|
|
|
const rom_4bit = (0x00<<14); /* ROM width */
|
|
const rom_8bit = (0x01<<14);
|
|
const rom_16bit = (0x02<<14);
|
|
|
|
const rom_never = (0x00<<12); /* Never run Boot Code */
|
|
const rom_install = (0x01<<12); /* run code at install time */
|
|
const rom_binddrv = (0x02<<12); /* run code with binddrivers */
|
|
|
|
//var chipdone = false;
|
|
|
|
/*const FILESYS_DIAGPOINT = 0x01e0;
|
|
const FILESYS_BOOTPOINT = 0x01e6;
|
|
const FILESYS_DIAGAREA = 0x2000;
|
|
uaecptr ROM_filesys_resname, ROM_filesys_resid;
|
|
uaecptr ROM_filesys_diagentry;
|
|
uaecptr ROM_hardfile_resname, ROM_hardfile_resid;
|
|
uaecptr ROM_hardfile_init;*/
|
|
|
|
/*---------------------------------*/
|
|
|
|
function card_data() {
|
|
this.initrc = null; //addrbank *(*initrc)(struct romconfig*);
|
|
this.initnum = null; //addrbank *(*initnum)(int);
|
|
this.map = null; //addrbank *(*map)(void);
|
|
this.rc = null; //struct romconfig *
|
|
this.name = "";
|
|
this.flags = 0;
|
|
this.zorro = 0;
|
|
}
|
|
var cards = new Array(MAX_EXPANSION_BOARD_SPACE);
|
|
for (var vi = 0; vi < MAX_EXPANSION_BOARD_SPACE; vi++)
|
|
cards[vi] = new card_data();
|
|
|
|
var ecard = 0, cardno = 0, cardid = 0;
|
|
|
|
/* Autoconfig address space at 0xE80000 */
|
|
const Z3BASE_UAE = 0x10000000;
|
|
const Z3BASE_REAL = 0x40000000;
|
|
|
|
var expamem = new Uint8Array(65536);
|
|
var expamem_lo = 0; //u8
|
|
var expamem_hi = 0; //u16
|
|
var expamem_z2_pointer = 0;
|
|
var expamem_z2_size = 0;
|
|
var expamem_z3_pointer = 0;
|
|
var expamem_z3_size = 0;
|
|
var expamem_z3_sum = 0;
|
|
var expamem_board_size = 0;
|
|
var expamem_board_pointer = 0
|
|
var expamem_bank_current = null;
|
|
|
|
var z3hack_override = false;
|
|
//var z3num = 0;
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Autoconfig base */
|
|
|
|
function isnonautoconfig(v) {
|
|
return v == BOARD_NONAUTOCONFIG_AFTER_Z2 ||
|
|
v == BOARD_NONAUTOCONFIG_AFTER_Z3 ||
|
|
v == BOARD_NONAUTOCONFIG_BEFORE;
|
|
}
|
|
|
|
/* Ugly hack for >2M chip RAM in single pool
|
|
* We can't add it any later or early boot menu
|
|
* stops working because it sets kicktag at the end
|
|
* of chip ram...
|
|
*/
|
|
/*function addextrachip(sysbase) {
|
|
var cs = SAEV_config.memory.chipSize;
|
|
if (cs <= 0x00200000)
|
|
return;
|
|
if (sysbase & 0x80000001)
|
|
return;
|
|
if (!SAER_Memory_check(sysbase, 1000))
|
|
return;
|
|
var ml = SAER_Memory_get32(sysbase + 322);
|
|
if (!SAER_Memory_check(ml, 32))
|
|
return;
|
|
var next = 0;
|
|
while ((next = SAER_Memory_get32(ml))) {
|
|
if (!SAER_Memory_check(ml, 32))
|
|
return;
|
|
var upper = SAER_Memory_get32(ml + 24);
|
|
var lower = SAER_Memory_get32(ml + 20);
|
|
if (lower & 0xffff0000) {
|
|
ml = next;
|
|
continue;
|
|
}
|
|
var attr = SAER_Memory_get16(ml + 14);
|
|
if ((attr & 0x8002) != 2) {
|
|
ml = next;
|
|
continue;
|
|
}
|
|
if (upper >= cs)
|
|
return;
|
|
var added = cs - upper;
|
|
var first = SAER_Memory_get32(ml + 16);
|
|
SAER_Memory_put32(ml + 24, cs); // mh_Upper
|
|
SAER_Memory_put32(ml + 28, SAER_Memory_get32(ml + 28) + added); // mh_Free
|
|
while (first) {
|
|
next = first;
|
|
first = SAER_Memory_get32(next);
|
|
}
|
|
var bytes = SAER_Memory_get32(next + 4);
|
|
if (next + bytes == 0x00200000) {
|
|
SAER_Memory_put32 (next + 4, cs - next);
|
|
} else {
|
|
SAER_Memory_put32(0x00200000 + 0, 0);
|
|
SAER_Memory_put32(0x00200000 + 4, added);
|
|
SAER_Memory_put32(next, 0x00200000);
|
|
}
|
|
return;
|
|
}
|
|
}*/
|
|
|
|
/*this.set_expamem_z3_hack_override = function(overridenoz3hack) {
|
|
z3hack_override = overridenoz3hack;
|
|
}*/
|
|
function expamem_z3hack(p) {
|
|
if (z3hack_override) return false;
|
|
return p.memory.z3Mapping == SAEC_Config_Memory_z3Mapping_Auto || p.memory.z3Mapping == SAEC_Config_Memory_z3Mapping_SAE; // || cpuboard_memorytype(p) == BOARD_MEMORY_BLIZZARD_12xx;
|
|
}
|
|
|
|
function expamem_map_clear() {
|
|
SAEF_warn("expamem_map_clear() got called. Shouldn't happen.");
|
|
return null;
|
|
}
|
|
|
|
function expamem_init_clear() {
|
|
//memset(expamem, 0xff, sizeof expamem);
|
|
SAEF_memset(expamem,0, 0xff, 65536);
|
|
}
|
|
/* autoconfig area is "non-existing" after last device */
|
|
function expamem_init_clear_zero() {
|
|
SAER_Memory_mapBanks(SAEV_Memory_dummyBank, 0xe8, 1, 0);
|
|
if (!SAEV_config.cpu.addressSpace24)
|
|
SAER_Memory_mapBanks(SAEV_Memory_dummyBank, 0xff000000 >>> 16, 1, 0);
|
|
}
|
|
|
|
function expamem_init_clear2() {
|
|
expamem_bank.name = "Autoconfig Z2";
|
|
expamemz3_bank.name = "Autoconfig Z3";
|
|
expamem_init_clear_zero();
|
|
ecard = cardno;
|
|
}
|
|
|
|
function expamem_init_last() {
|
|
expamem_init_clear2();
|
|
SAEF_log("Memory map after autoconfig:");
|
|
SAER.memory.map_dump();
|
|
return null;
|
|
}
|
|
|
|
function expamem_read(addr) {
|
|
var b = (expamem[addr] & 0xf0) | (expamem[addr + 2] >> 4);
|
|
if (addr == 0 || addr == 2 || addr == 0x40 || addr == 0x42)
|
|
return b;
|
|
b = ~b;
|
|
return b & 0xff;
|
|
}
|
|
|
|
function expamem_write(addr, value) {
|
|
addr &= 0xffff;
|
|
if (addr == 0 || addr == 2 || addr == 0x40 || addr == 0x42) {
|
|
expamem[addr] = (value & 0xf0);
|
|
expamem[addr + 2] = (value & 0x0f) << 4;
|
|
} else {
|
|
expamem[addr] = ~(value & 0xf0);
|
|
expamem[addr + 2] = ~((value & 0x0f) << 4);
|
|
}
|
|
}
|
|
|
|
function expamem_type() {
|
|
return expamem_read(0) & 0xc0;
|
|
}
|
|
|
|
function call_card_init(index) {
|
|
var ab;
|
|
|
|
expamem_bank.name = cards[ecard].name ? cards[ecard].name : "None";
|
|
if (cards[ecard].initnum)
|
|
ab = cards[ecard].initnum(0);
|
|
else
|
|
ab = cards[ecard].initrc(cards[ecard].rc);
|
|
|
|
expamem_z3_size = 0;
|
|
/*if (ab === expamem_none) { //cpu-boards
|
|
expamem_init_clear();
|
|
expamem_init_clear_zero();
|
|
SAER_Memory_mapBanks(expamem_bank, 0xE8, 1, 0);
|
|
if (!SAEV_config.cpu.addressSpace24)
|
|
SAER_Memory_mapBanks(SAEV_Memory_dummyBank, 0xff000000 >>> 16, 1, 0);
|
|
expamem_bank_current = null;
|
|
return;
|
|
}*/
|
|
if (ab === false) { //expamem_null) {
|
|
expamem_next(null, null);
|
|
return;
|
|
}
|
|
|
|
var abe = ab;
|
|
if (abe === null)
|
|
abe = expamem_bank;
|
|
if (abe !== expamem_bank) {
|
|
for (var i = 0; i < 16 * 4; i++)
|
|
expamem[i] = abe.get8(i);
|
|
}
|
|
|
|
var code = expamem_read(0);
|
|
if ((code & 0xc0) == zorroII) {
|
|
// Z2
|
|
code &= 7;
|
|
if (code == 0)
|
|
expamem_z2_size = 8 * 1024 * 1024;
|
|
else
|
|
expamem_z2_size = 32768 << code;
|
|
|
|
expamem_board_size = expamem_z2_size;
|
|
expamem_board_pointer = expamem_z2_pointer;
|
|
|
|
} else if ((code & 0xc0) == zorroIII) {
|
|
// Z3
|
|
if (expamem_z3_sum < Z3BASE_UAE) {
|
|
expamem_z3_sum = SAEV_config.memory.z3AutoConfigStart;
|
|
if (SAEV_config.memory.ramsey.highSize >= 128 * 1024 * 1024 && expamem_z3_sum == Z3BASE_UAE)
|
|
expamem_z3_sum += (SAEV_config.memory.ramsey.highSize - 128 * 1024 * 1024) + 16 * 1024 * 1024;
|
|
if (!expamem_z3hack(SAEV_config))
|
|
expamem_z3_sum = Z3BASE_REAL;
|
|
//if (expamem_z3_sum == Z3BASE_UAE)
|
|
// expamem_z3_sum += currprefs.z3chipmem_size;
|
|
}
|
|
|
|
expamem_z3_pointer = expamem_z3_sum;
|
|
|
|
code &= 7;
|
|
if (expamem_read(8) & ext_size)
|
|
expamem_z3_size = (16 * 1024 * 1024) << code;
|
|
else
|
|
expamem_z3_size = 16 * 1024 * 1024;
|
|
expamem_z3_sum += expamem_z3_size;
|
|
|
|
var expamem_z3_pointer_old = expamem_z3_pointer;
|
|
// align 32M boards (FastLane is 32M and needs to be aligned)
|
|
if (expamem_z3_size <= 32 * 1024 * 1024)
|
|
expamem_z3_pointer = ((expamem_z3_pointer + expamem_z3_size - 1) & ~(expamem_z3_size - 1)) >>> 0;
|
|
|
|
expamem_z3_sum += expamem_z3_pointer - expamem_z3_pointer_old;
|
|
|
|
expamem_board_size = expamem_z3_size;
|
|
expamem_board_pointer = expamem_z3_pointer;
|
|
|
|
} else if ((code & 0xc0) == 0x40) {
|
|
// 0x40 = "Box without init/diagnostic code"
|
|
// proto autoconfig "box" size.
|
|
//expamem_z2_size = (1 << ((code >> 3) & 7)) * 4096;
|
|
// much easier this way, all old-style boards were made for
|
|
// A1000 and didn"t have passthrough connector.
|
|
expamem_z2_size = 65536;
|
|
expamem_board_size = expamem_z2_size;
|
|
expamem_board_pointer = expamem_z2_pointer;
|
|
}
|
|
|
|
if (ab !== null) {
|
|
// non-null: not using expamem_bank
|
|
expamem_bank_current = ab;
|
|
if ((cards[ecard].flags & 1) && SAEV_config.chipset.z3AutoConfig && !SAEV_config.cpu.addressSpace24) {
|
|
SAER_Memory_mapBanks(expamemz3_bank, 0xff000000 >>> 16, 1, 0);
|
|
SAER_Memory_mapBanks(SAEV_Memory_dummyBank, 0xE8, 1, 0);
|
|
} else {
|
|
SAER_Memory_mapBanks(expamem_bank, 0xE8, 1, 0);
|
|
if (!SAEV_config.cpu.addressSpace24)
|
|
SAER_Memory_mapBanks(SAEV_Memory_dummyBank, 0xff000000 >>> 16, 1, 0);
|
|
}
|
|
} else {
|
|
if ((cards[ecard].flags & 1) && SAEV_config.chipset.z3AutoConfig && !SAEV_config.cpu.addressSpace24) {
|
|
expamem_bank_current = expamem_bank;
|
|
SAER_Memory_mapBanks(expamemz3_bank, 0xff000000 >>> 16, 1, 0);
|
|
SAER_Memory_mapBanks(SAEV_Memory_dummyBank, 0xE8, 1, 0);
|
|
} else {
|
|
expamem_bank_current = null;
|
|
SAER_Memory_mapBanks(expamem_bank, 0xE8, 1, 0);
|
|
if (!SAEV_config.cpu.addressSpace24)
|
|
SAER_Memory_mapBanks(SAEV_Memory_dummyBank, 0xff000000 >>> 16, 1, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
function boardmessage(mapped, success) {
|
|
var type = expamem_read(0);
|
|
var size = expamem_board_size;
|
|
var sizemod = "K";
|
|
|
|
//size /= 1024;
|
|
size >>>= 10;
|
|
if (size > 8 * 1024) {
|
|
sizemod = "M";
|
|
//size /= 1024;
|
|
size >>>= 10;
|
|
}
|
|
SAEF_log("memory.boardmessage() Card %d: Z%d 0x%08x %4d%s %s %s%s",
|
|
ecard + 1, (type & 0xc0) == zorroII ? 2 : ((type & 0xc0) == zorroIII ? 3 : 1),
|
|
expamem_board_pointer, size, sizemod,
|
|
type & rom_card ? "ROM" : (type & add_memory ? "RAM" : "IO "),
|
|
mapped.name,
|
|
success ? "" : " SHUT UP"
|
|
);
|
|
/*#if 0
|
|
for (var i = 0; i < 16; i++) {
|
|
SAEF_log("%s%02X", i > 0 ? "." : "", expamem_read(i * 4));
|
|
}
|
|
SAEF_log("\n");
|
|
#endif*/
|
|
}
|
|
|
|
function expamem_shutup(mapped) {
|
|
if (mapped)
|
|
boardmessage(mapped, false);
|
|
}
|
|
|
|
function expamem_next(mapped, next) {
|
|
if (mapped)
|
|
boardmessage(mapped, true);
|
|
|
|
expamem_init_clear();
|
|
expamem_init_clear_zero();
|
|
for (;;) {
|
|
++ecard;
|
|
if (ecard >= cardno)
|
|
break;
|
|
var ec = cards[ecard];
|
|
if (ec.initrc && isnonautoconfig(ec.zorro)) {
|
|
ec.initrc(cards[ecard].rc);
|
|
} else {
|
|
call_card_init(ecard);
|
|
break;
|
|
}
|
|
}
|
|
if (ecard >= cardno) {
|
|
expamem_init_clear2();
|
|
expamem_init_last();
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* BANK Z2-Fast memory */
|
|
|
|
function fastmem_get32(addr) {
|
|
addr = (addr & fastmem_bank.mask) >>> 0;
|
|
//var m = fastmem_bank.baseaddr + addr; return do_get_mem_long ((uae_u32 *)m);
|
|
return ((fastmem_bank.baseaddr[addr] << 24) | (fastmem_bank.baseaddr[addr+1] << 16) | (fastmem_bank.baseaddr[addr+2] << 8) | fastmem_bank.baseaddr[addr+3]) >>> 0;
|
|
}
|
|
function fastmem_get16(addr) {
|
|
addr = (addr & fastmem_bank.mask) >>> 0;
|
|
//var m = fastmem_bank.baseaddr + addr; return do_get_mem_word ((uae_u16 *)m);
|
|
return (fastmem_bank.baseaddr[addr] << 8) | fastmem_bank.baseaddr[addr+1];
|
|
}
|
|
function fastmem_get8(addr) {
|
|
addr = (addr & fastmem_bank.mask) >>> 0;
|
|
return fastmem_bank.baseaddr[addr];
|
|
}
|
|
function fastmem_put32(addr, l) {
|
|
addr = (addr & fastmem_bank.mask) >>> 0;
|
|
//var m = fastmem_bank.baseaddr + addr; do_put_mem_long ((uae_u32 *)m, l);
|
|
fastmem_bank.baseaddr[addr] = l >>> 24;
|
|
fastmem_bank.baseaddr[addr+1] = (l >>> 16) & 0xff;
|
|
fastmem_bank.baseaddr[addr+2] = (l >>> 8) & 0xff;
|
|
fastmem_bank.baseaddr[addr+3] = l & 0xff;
|
|
}
|
|
function fastmem_put16(addr, w) {
|
|
addr = (addr & fastmem_bank.mask) >>> 0;
|
|
//var m = fastmem_bank.baseaddr + addr; do_put_mem_word ((uae_u16 *)m, w);
|
|
fastmem_bank.baseaddr[addr] = w >> 8;
|
|
fastmem_bank.baseaddr[addr+1] = w & 0xff;
|
|
}
|
|
function fastmem_put8(addr, b) {
|
|
addr = (addr & fastmem_bank.mask) >>> 0;
|
|
fastmem_bank.baseaddr[addr] = b;
|
|
}
|
|
function fastmem_check(addr, size) {
|
|
addr = (addr & fastmem_bank.mask) >>> 0;
|
|
return (addr + size) <= fastmem_bank.allocated;
|
|
}
|
|
function fastmem_xlate(addr) {
|
|
addr = (addr & fastmem_bank.mask) >>> 0;
|
|
//return fastmem_bank.baseaddr + addr;
|
|
return addr;
|
|
}
|
|
var fastmem_bank = new SAEO_Memory_addrbank(
|
|
fastmem_get32, fastmem_get16, fastmem_get8,
|
|
fastmem_put32, fastmem_put16, fastmem_put8,
|
|
fastmem_xlate, fastmem_check, null, "fast", "Fast memory",
|
|
fastmem_get32, fastmem_get16,
|
|
//SAEC_Memory_addrbank_flag_RAM | SAEC_Memory_addrbank_flag_THREADSAFE, 0, 0
|
|
SAEC_Memory_addrbank_flag_RAM | SAEC_Memory_addrbank_flag_THREADSAFE
|
|
);
|
|
|
|
/*---------------------------------*/
|
|
|
|
/*var fastmem2_bank = new SAEO_Memory_addrbank(
|
|
fastmem2_get32, fastmem2_get16, fastmem2_get8,
|
|
fastmem2_put32, fastmem2_put16, fastmem2_put8,
|
|
fastmem2_xlate, fastmem2_check, null, "fast2", "Fast memory 2",
|
|
fastmem2_get32, fastmem2_get16,
|
|
//SAEC_Memory_addrbank_flag_RAM | SAEC_Memory_addrbank_flag_THREADSAFE, 0, 0
|
|
SAEC_Memory_addrbank_flag_RAM | SAEC_Memory_addrbank_flag_THREADSAFE
|
|
};*/
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
function fastmem_autoconfig(boardnum, zorro, type, serial, allocated) {
|
|
var mid = 0;
|
|
var pid;
|
|
var flags = care_addr;
|
|
//DEVICE_MEMORY_CALLBACK dmc = null;
|
|
//struct romconfig *dmc_rc = null;
|
|
var ac = new Uint8Array(16);
|
|
|
|
/*if (boardnum == 1) {
|
|
|
|
} else if (boardnum == 0) {
|
|
for (int i = 0; expansionroms[i].name; i++) {
|
|
const struct expansionromtype *erc = &expansionroms[i];
|
|
if (((erc->zorro == zorro) || (zorro < 0 && erc->zorro >= BOARD_NONAUTOCONFIG_BEFORE)) && cfgfile_board_enabled(&currprefs, erc->romtype, 0)) {
|
|
struct romconfig *rc = get_device_romconfig(&currprefs, erc->romtype, 0);
|
|
if (erc->subtypes) {
|
|
const struct expansionsubromtype *srt = &erc->subtypes[rc->subtype];
|
|
if (srt->memory_mid) {
|
|
mid = srt->memory_mid;
|
|
pid = srt->memory_pid;
|
|
serial = srt->memory_serial;
|
|
if (!srt->memory_after)
|
|
type |= chainedconfig;
|
|
}
|
|
} else {
|
|
if (erc->memory_mid) {
|
|
mid = erc->memory_mid;
|
|
pid = erc->memory_pid;
|
|
serial = erc->memory_serial;
|
|
if (!erc->memory_after)
|
|
type |= chainedconfig;
|
|
}
|
|
}
|
|
dmc = erc->memory_callback;
|
|
dmc_rc = rc;
|
|
break;
|
|
}
|
|
}
|
|
}*/
|
|
|
|
if (!mid) {
|
|
if (zorro <= 2) {
|
|
//pid = SAEV_config.memory.maprom ? 1 : 81;
|
|
pid = 81;
|
|
} else {
|
|
var subsize = (allocated == 0x100000 ? Z3_SS_MEM_1MB
|
|
: allocated == 0x200000 ? Z3_SS_MEM_2MB
|
|
: allocated == 0x400000 ? Z3_SS_MEM_4MB
|
|
: allocated == 0x800000 ? Z3_SS_MEM_8MB
|
|
: Z3_SS_MEM_SAME);
|
|
|
|
//pid = SAEV_config.memory.maprom ? 3 : 83;
|
|
pid = 83;
|
|
flags |= force_z3 | (allocated > 0x800000 ? ext_size : subsize);
|
|
}
|
|
mid = cardid;
|
|
}
|
|
|
|
ac[0x00 / 4] = type;
|
|
ac[0x04 / 4] = pid;
|
|
ac[0x08 / 4] = flags;
|
|
ac[0x10 / 4] = mid >> 8;
|
|
ac[0x14 / 4] = mid & 0xff;
|
|
ac[0x18 / 4] = serial >>> 24;
|
|
ac[0x1c / 4] = (serial >>> 16) & 0xff;
|
|
ac[0x20 / 4] = (serial >>> 8) & 0xff;
|
|
ac[0x24 / 4] = serial & 0xff;
|
|
|
|
//if (dmc && dmc_rc) dmc(dmc_rc, ac, allocated);
|
|
|
|
expamem_write(0x00, ac[0x00 / 4]);
|
|
expamem_write(0x04, ac[0x04 / 4]);
|
|
expamem_write(0x08, ac[0x08 / 4]);
|
|
expamem_write(0x10, ac[0x10 / 4]);
|
|
expamem_write(0x14, ac[0x14 / 4]);
|
|
|
|
expamem_write(0x18, ac[0x18 / 4]); /* ser.no. Byte 0 */
|
|
expamem_write(0x1c, ac[0x1c / 4]); /* ser.no. Byte 1 */
|
|
expamem_write(0x20, ac[0x20 / 4]); /* ser.no. Byte 2 */
|
|
expamem_write(0x24, ac[0x24 / 4]); /* ser.no. Byte 3 */
|
|
|
|
expamem_write(0x28, 0x00); /* ROM-Offset hi */
|
|
expamem_write(0x2c, 0x00); /* ROM-Offset lo */
|
|
|
|
expamem_write(0x40, 0x00); /* Ctrl/Statusreg.*/
|
|
}
|
|
|
|
/*---------------------------------*/
|
|
/* Expansion Card (ZORRO II) */
|
|
|
|
function expamem_map_fastcard_2(boardnum) {
|
|
var start = ((expamem_hi | (expamem_lo >> 4)) << 16) >>> 0;
|
|
//var ab = fastbanks[boardnum * 2 + ((start < 0x00A00000) ? 0 : 1)];
|
|
var ab = fastmem_bank;
|
|
var size = ab.allocated;
|
|
ab.start = start;
|
|
if (ab.start)
|
|
SAER.memory.map_banks_z2(ab, ab.start >>> 16, size >>> 16);
|
|
|
|
return ab;
|
|
}
|
|
|
|
function expamem_init_fastcard_2(boardnum) {
|
|
var type = add_memory | zorroII;
|
|
//var allocated = boardnum ? fastmem2_bank.allocated : fastmem_bank.allocated;
|
|
var allocated = fastmem_bank.allocated;
|
|
var serial = 1;
|
|
|
|
if (allocated == 0)
|
|
return false; //expamem_null;
|
|
|
|
expamem_init_clear();
|
|
|
|
if (allocated == 65536) type |= Z2_MEM_64KB;
|
|
else if (allocated == 131072) type |= Z2_MEM_128KB;
|
|
else if (allocated == 262144) type |= Z2_MEM_256KB;
|
|
else if (allocated == 524288) type |= Z2_MEM_512KB;
|
|
else if (allocated == 0x100000) type |= Z2_MEM_1MB;
|
|
else if (allocated == 0x200000) type |= Z2_MEM_2MB;
|
|
else if (allocated == 0x400000) type |= Z2_MEM_4MB;
|
|
else if (allocated == 0x800000) type |= Z2_MEM_8MB;
|
|
|
|
/*if (boardnum == 1) {
|
|
const a2630_autoconfig = [ 0xe7, 0x51, 0x40, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ];
|
|
|
|
if (ISCPUBOARD(BOARD_COMMODORE, BOARD_COMMODORE_SUB_A26x0)) {
|
|
for (int i = 1; i < 16; i++)
|
|
expamem_write(i * 4, a2630_autoconfig[i]);
|
|
type &= 7;
|
|
type |= a2630_autoconfig[0] & ~7;
|
|
expamem_write(0, type);
|
|
return null;
|
|
}
|
|
}*/
|
|
|
|
fastmem_autoconfig(boardnum, BOARD_AUTOCONFIG_Z2, type, serial, allocated);
|
|
fastmem_autoconfig(boardnum, -1, type, serial, allocated);
|
|
return null;
|
|
}
|
|
|
|
function expamem_init_fastcard(boardnum) {
|
|
return expamem_init_fastcard_2(0);
|
|
}
|
|
function expamem_map_fastcard() {
|
|
return expamem_map_fastcard_2(0);
|
|
}
|
|
|
|
/*function expamem_init_fastcard2(boardnum) {
|
|
return expamem_init_fastcard_2(1);
|
|
}
|
|
function expamem_map_fastcard2() {
|
|
return expamem_map_fastcard_2(1);
|
|
}*/
|
|
|
|
/*this.expansion_is_next_board_fastram = function() {
|
|
return ecard + 1 < MAX_EXPANSION_BOARD_SPACE && cards[ecard + 1].map == expamem_map_fastcard;
|
|
}*/
|
|
|
|
/*---------------------------------*/
|
|
/* Expansion Card (Zorro III) */
|
|
|
|
function expamem_map_z3fastmem_2(bank, ptr, size, allocated, chip) {
|
|
var z3fs = expamem_z3_pointer;
|
|
var start = ptr.start;
|
|
|
|
if (expamem_z3hack(SAEV_config)) {
|
|
if (z3fs && start != z3fs) {
|
|
SAEF_warn("memory.expamem_map_z3fastmem_2() Z3MEM mapping changed from $%08x to $%08x", start, z3fs);
|
|
map_banks(SAEV_Memory_dummyBank, start >>> 16, size >>> 16, allocated);
|
|
ptr.start = z3fs;
|
|
SAER.memory.map_banks_z3(bank, start >>> 16, size >>> 16);
|
|
}
|
|
} else {
|
|
SAER.memory.map_banks_z3(bank, z3fs >>> 16, size >>> 16);
|
|
//start = z3fs; //OWN unneeded
|
|
ptr.start = z3fs;
|
|
}
|
|
return bank;
|
|
}
|
|
function expamem_map_z3fastmem() {
|
|
var ptr = { start:z3fastmem_bank.start };
|
|
var bank = expamem_map_z3fastmem_2(z3fastmem_bank, ptr, SAEV_config.memory.z3FastSize, z3fastmem_bank.allocated, 0);
|
|
z3fastmem_bank.start = ptr.start;
|
|
return bank;
|
|
}
|
|
/*function expamem_map_z3fastmem2() {
|
|
var ptr = { start:z3fastmem2_bank.start };
|
|
var bank = expamem_map_z3fastmem_2(z3fastmem2_bank, ptr, currprefs.z3fastmem2_size, z3fastmem2_bank.allocated, 0);
|
|
z3fastmem2_bank.start = ptr.start;
|
|
return bank;
|
|
}*/
|
|
|
|
function expamem_init_z3fastmem_2(boardnum, bank, start, size, allocated) {
|
|
var code = (allocated == 0x100000 ? Z2_MEM_1MB
|
|
: allocated == 0x200000 ? Z2_MEM_2MB
|
|
: allocated == 0x400000 ? Z2_MEM_4MB
|
|
: allocated == 0x800000 ? Z2_MEM_8MB
|
|
: allocated == 0x1000000 ? Z3_MEM_16MB
|
|
: allocated == 0x2000000 ? Z3_MEM_32MB
|
|
: allocated == 0x4000000 ? Z3_MEM_64MB
|
|
: allocated == 0x8000000 ? Z3_MEM_128MB
|
|
: allocated == 0x10000000 ? Z3_MEM_256MB
|
|
: allocated == 0x20000000 ? Z3_MEM_512MB
|
|
: Z3_MEM_1GB);
|
|
|
|
if (allocated < 0x1000000)
|
|
code = Z3_MEM_16MB; /* Z3 physical board size is always at least 16M */
|
|
|
|
expamem_init_clear();
|
|
fastmem_autoconfig(boardnum, BOARD_AUTOCONFIG_Z3, add_memory | zorroIII | code, 1, allocated);
|
|
SAER.memory.map_banks_z3(bank, start >>> 16, size >>> 16);
|
|
return null;
|
|
}
|
|
function expamem_init_z3fastmem(devnum) {
|
|
return expamem_init_z3fastmem_2(0, z3fastmem_bank, z3fastmem_bank.start, SAEV_config.memory.z3FastSize, z3fastmem_bank.allocated);
|
|
}
|
|
/*function expamem_init_z3fastmem2(devnum) {
|
|
return expamem_init_z3fastmem_2(1, z3fastmem2_bank, z3fastmem2_bank.start, currprefs.z3fastmem2_size, z3fastmem2_bank.allocated);
|
|
}*/
|
|
|
|
/*---------------------------------*/
|
|
/* BANK Z3 memory */
|
|
|
|
function z3fastmem_get32(addr) {
|
|
addr = (addr & z3fastmem_bank.mask) >>> 0;
|
|
//var m = z3fastmem_bank.baseaddr + addr; return do_get_mem_long ((uae_u32 *)m);
|
|
return ((z3fastmem_bank.baseaddr[addr] << 24) | (z3fastmem_bank.baseaddr[addr+1] << 16) | (z3fastmem_bank.baseaddr[addr+2] << 8) | z3fastmem_bank.baseaddr[addr+3]) >>> 0;
|
|
}
|
|
function z3fastmem_get16(addr) {
|
|
addr = (addr & z3fastmem_bank.mask) >>> 0;
|
|
//var m = z3fastmem_bank.baseaddr + addr; return do_get_mem_word ((uae_u16 *)m);
|
|
return (z3fastmem_bank.baseaddr[addr] << 8) | z3fastmem_bank.baseaddr[addr+1];
|
|
}
|
|
function z3fastmem_get8(addr) {
|
|
addr = (addr & z3fastmem_bank.mask) >>> 0;
|
|
return z3fastmem_bank.baseaddr[addr];
|
|
}
|
|
function z3fastmem_put32(addr, l) {
|
|
addr = (addr & z3fastmem_bank.mask) >>> 0;
|
|
//var m = z3fastmem_bank.baseaddr + addr; do_put_mem_long ((uae_u32 *)m, l);
|
|
z3fastmem_bank.baseaddr[addr] = l >>> 24;
|
|
z3fastmem_bank.baseaddr[addr+1] = (l >>> 16) & 0xff;
|
|
z3fastmem_bank.baseaddr[addr+2] = (l >>> 8) & 0xff;
|
|
z3fastmem_bank.baseaddr[addr+3] = l & 0xff;
|
|
}
|
|
function z3fastmem_put16(addr, w) {
|
|
addr = (addr & z3fastmem_bank.mask) >>> 0;
|
|
//var m = z3fastmem_bank.baseaddr + addr; do_put_mem_word ((uae_u16 *)m, w);
|
|
z3fastmem_bank.baseaddr[addr] = w >> 8;
|
|
z3fastmem_bank.baseaddr[addr+1] = w & 0xff;
|
|
}
|
|
function z3fastmem_put8(addr, b) {
|
|
addr = (addr & z3fastmem_bank.mask) >>> 0;
|
|
z3fastmem_bank.baseaddr[addr] = b;
|
|
}
|
|
function z3fastmem_check(addr, size) {
|
|
addr = (addr & z3fastmem_bank.mask) >>> 0;
|
|
return (addr + size) <= z3fastmem_bank.allocated;
|
|
}
|
|
function z3fastmem_xlate(addr) {
|
|
addr = (addr & z3fastmem_bank.mask) >>> 0;
|
|
//return z3fastmem_bank.baseaddr + addr;
|
|
return addr;
|
|
}
|
|
var z3fastmem_bank = new SAEO_Memory_addrbank(
|
|
z3fastmem_get32, z3fastmem_get16, z3fastmem_get8,
|
|
z3fastmem_put32, z3fastmem_put16, z3fastmem_put8,
|
|
z3fastmem_xlate, z3fastmem_check, null, "z3", "Zorro III Fast RAM",
|
|
z3fastmem_get32, z3fastmem_get16,
|
|
//SAEC_Memory_addrbank_flag_RAM | SAEC_Memory_addrbank_flag_THREADSAFE, 0, 0
|
|
SAEC_Memory_addrbank_flag_RAM | SAEC_Memory_addrbank_flag_THREADSAFE
|
|
);
|
|
SAER_Expansion_z3fastmem_bank = z3fastmem_bank;
|
|
|
|
/*MEMORY_FUNCTIONS(z3fastmem2);
|
|
var z3fastmem2_bank = new SAEO_Memory_addrbank(
|
|
z3fastmem2_get32, z3fastmem2_get16, z3fastmem2_get8,
|
|
z3fastmem2_put32, z3fastmem2_put16, z3fastmem2_put8,
|
|
z3fastmem2_xlate, z3fastmem2_check, null, "z3_2", "Zorro III Fast RAM #2",
|
|
z3fastmem2_get32, z3fastmem2_get16,
|
|
//SAEC_Memory_addrbank_flag_RAM | SAEC_Memory_addrbank_flag_THREADSAFE, 0, 0
|
|
SAEC_Memory_addrbank_flag_RAM | SAEC_Memory_addrbank_flag_THREADSAFE
|
|
);
|
|
|
|
MEMORY_FUNCTIONS(z3chipmem);
|
|
var z3chipmem_bank = new SAEO_Memory_addrbank(
|
|
z3chipmem_get32, z3chipmem_get16, z3chipmem_get8,
|
|
z3chipmem_put32, z3chipmem_put16, z3chipmem_put8,
|
|
z3chipmem_xlate, z3chipmem_check, null, "z3_chip", "MegaChipRAM",
|
|
z3chipmem_get32, z3chipmem_get16,
|
|
//SAEC_Memory_addrbank_flag_RAM | SAEC_Memory_addrbank_flag_THREADSAFE, 0, 0
|
|
SAEC_Memory_addrbank_flag_RAM | SAEC_Memory_addrbank_flag_THREADSAFE
|
|
);*/
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Autoconfig setup/cleanup/reset */
|
|
|
|
function mapped_malloc(ab) {
|
|
ab.startmask = ab.start;
|
|
try {
|
|
//ab.baseaddr = xcalloc(uae_u8, ab.allocated + 4);
|
|
ab.baseaddr = new Uint8Array(ab.allocated + 4);
|
|
return true;
|
|
} catch (e) {
|
|
ab.baseaddr = null;
|
|
return false;
|
|
}
|
|
}
|
|
function mapped_free(ab) {
|
|
//xfree(ab.baseaddr);
|
|
ab.baseaddr = null;
|
|
}
|
|
|
|
function free_fastmemory(boardnum) {
|
|
if (boardnum == 0)
|
|
mapped_free(fastmem_bank);
|
|
//else
|
|
//mapped_free(fastmem2_bank);
|
|
}
|
|
this.free_fastmemory_ext = function(boardnum) {
|
|
free_fastmemory(boardnum);
|
|
}
|
|
|
|
//function mapped_malloc_dynamic(curr, changed, bank, max, name) {
|
|
function mapped_malloc_dynamic(curr, bank, max, name) {
|
|
var alloc = curr.size;
|
|
|
|
bank.allocated = 0;
|
|
bank.baseaddr = null;
|
|
bank.mask = 0;
|
|
|
|
if (!alloc)
|
|
return false;
|
|
|
|
while (alloc >= max * 1024 * 1024) {
|
|
bank.mask = alloc - 1;
|
|
bank.allocated = alloc;
|
|
bank.label = name;
|
|
if (mapped_malloc(bank)) {
|
|
curr.size = alloc;
|
|
//changed.size = alloc;
|
|
return true;
|
|
}
|
|
SAEF_warn("expansion.mapped_malloc_dynamic() out of memory for '%s'. (%d bytes)", name, alloc);
|
|
alloc >>>= 1;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*uaecptr expansion_startaddress(uaecptr addr, uae_u32 size) {
|
|
if (!size)
|
|
return addr;
|
|
if (size < 16 * 1024 * 1024)
|
|
size = 16 * 1024 * 1024;
|
|
if (!expamem_z3hack(SAEV_config))
|
|
return (addr + size - 1) & ~(size - 1);
|
|
return addr;
|
|
}*/
|
|
|
|
function allocate() { //allocate_expamem
|
|
/*z3chipmem_bank.start = Z3BASE_UAE;
|
|
if (SAEV_config.memory.ramsey.highSize >= 128 * 1024 * 1024)
|
|
z3chipmem_bank.start += (SAEV_config.memory.ramsey.highSize - 128 * 1024 * 1024) + 16 * 1024 * 1024;*/
|
|
|
|
z3fastmem_bank.start = SAEV_config.memory.z3AutoConfigStart;
|
|
if (!expamem_z3hack(SAEV_config))
|
|
z3fastmem_bank.start = Z3BASE_REAL;
|
|
if (z3fastmem_bank.start == Z3BASE_UAE) {
|
|
if (SAEV_config.memory.ramsey.highSize >= 128 * 1024 * 1024)
|
|
z3fastmem_bank.start += (SAEV_config.memory.ramsey.highSize - 128 * 1024 * 1024) + 16 * 1024 * 1024;
|
|
//z3fastmem_bank.start += currprefs.z3chipmem_size;
|
|
}
|
|
/*z3fastmem2_bank.start = z3fastmem_bank.start + SAEV_config.memory.z3FastSize;
|
|
|
|
if (currprefs.z3chipmem_size && z3fastmem_bank.start - z3chipmem_bank.start < currprefs.z3chipmem_size)
|
|
currprefs.z3chipmem_size = changed_prefs.z3chipmem_size = 0;*/
|
|
|
|
if (fastmem_bank.allocated != SAEV_config.memory.z2FastSize) {
|
|
free_fastmemory(0);
|
|
|
|
fastmem_bank.allocated = SAEV_config.memory.z2FastSize;
|
|
fastmem_bank.mask = fastmem_bank.allocated - 1;
|
|
|
|
//fastmem_nojit_bank.allocated = fastmem_bank.allocated;
|
|
//fastmem_nojit_bank.mask = fastmem_bank.mask;
|
|
|
|
if (fastmem_bank.allocated) {
|
|
mapped_malloc(fastmem_bank);
|
|
/*fastmem_nojit_bank.baseaddr = fastmem_bank.baseaddr;
|
|
if (fastmem_bank.baseaddr == 0) {
|
|
SAEF_error("Out of memory for fastmem card.");
|
|
fastmem_bank.allocated = 0;
|
|
fastmem_nojit_bank.allocated = 0;
|
|
}*/
|
|
}
|
|
SAER.memory.hardreset(1);
|
|
}
|
|
|
|
/*if (fastmem2_bank.allocated != currprefs.fastmem2_size) {
|
|
free_fastmemory(1);
|
|
|
|
fastmem2_bank.allocated = currprefs.fastmem2_size;
|
|
fastmem2_bank.mask = fastmem2_bank.allocated - 1;
|
|
|
|
fastmem2_nojit_bank.allocated = fastmem2_bank.allocated;
|
|
fastmem2_nojit_bank.mask = fastmem2_bank.mask;
|
|
|
|
if (fastmem2_bank.allocated) {
|
|
mapped_malloc (&fastmem2_bank);
|
|
fastmem2_nojit_bank.baseaddr = fastmem2_bank.baseaddr;
|
|
if (fastmem2_bank.baseaddr == 0) {
|
|
SAEF_error("Out of memory for fastmem2 card.");
|
|
fastmem2_bank.allocated = 0;
|
|
fastmem2_nojit_bank.allocated = 0;
|
|
}
|
|
}
|
|
SAER.memory.hardreset(1);
|
|
}*/
|
|
|
|
if (z3fastmem_bank.allocated != SAEV_config.memory.z3FastSize) {
|
|
mapped_free(z3fastmem_bank);
|
|
//mapped_malloc_dynamic(SAEV_config.memory.z3FastSize, &changed_prefs.z3fastmem_size, z3fastmem_bank, 1, "z3");
|
|
var curr = { size:SAEV_config.memory.z3FastSize };
|
|
mapped_malloc_dynamic(curr, z3fastmem_bank, 1, "z3");
|
|
SAEV_config.memory.z3FastSize = curr.size;
|
|
SAER.memory.hardreset(1);
|
|
}
|
|
/*if (z3fastmem2_bank.allocated != currprefs.z3fastmem2_size) {
|
|
mapped_free (&z3fastmem2_bank);
|
|
|
|
z3fastmem2_bank.allocated = currprefs.z3fastmem2_size;
|
|
z3fastmem2_bank.mask = z3fastmem2_bank.allocated - 1;
|
|
|
|
if (z3fastmem2_bank.allocated) {
|
|
mapped_malloc (&z3fastmem2_bank);
|
|
if (z3fastmem2_bank.baseaddr == 0) {
|
|
SAEF_error("Out of memory for 32 bit fast memory #2.");
|
|
z3fastmem2_bank.allocated = 0;
|
|
}
|
|
}
|
|
SAER.memory.hardreset(1);
|
|
}
|
|
if (z3chipmem_bank.allocated != currprefs.z3chipmem_size) {
|
|
mapped_free (&z3chipmem_bank);
|
|
mapped_malloc_dynamic(&currprefs.z3chipmem_size, &changed_prefs.z3chipmem_size, &z3chipmem_bank, 16, "z3_chip");
|
|
SAER.memory.hardreset(1);
|
|
}*/
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
/*static bool add_fastram_after_expansion(int zorro)
|
|
{
|
|
for (int i = 0; expansionroms[i].name; i++) {
|
|
const struct expansionromtype *ert = &expansionroms[i];
|
|
if (ert->zorro == zorro) {
|
|
for (int j = 0; j < MAX_DUPLICATE_EXPANSION_BOARDS; j++) {
|
|
struct romconfig *rc = get_device_romconfig(&currprefs, ert->romtype, j);
|
|
if (rc) {
|
|
if (ert->subtypes) {
|
|
const struct expansionsubromtype *srt = &ert->subtypes[rc->subtype];
|
|
return srt->memory_after;
|
|
}
|
|
return ert->memory_after;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void add_expansions(int zorro)
|
|
{
|
|
for (int i = 0; expansionroms[i].name; i++) {
|
|
const struct expansionromtype *ert = &expansionroms[i];
|
|
if (ert->zorro == zorro) {
|
|
for (int j = 0; j < MAX_DUPLICATE_EXPANSION_BOARDS; j++) {
|
|
struct romconfig *rc = get_device_romconfig(&currprefs, ert->romtype, j);
|
|
if (rc) {
|
|
if (zorro == 1) {
|
|
ert->init(rc);
|
|
if (ert->init2)
|
|
ert->init2(rc);
|
|
} else {
|
|
cards[cardno].flags = 0;
|
|
cards[cardno].name = ert->name;
|
|
cards[cardno].initrc = ert->init;
|
|
cards[cardno].rc = rc;
|
|
cards[cardno].zorro = zorro;
|
|
cards[cardno++].map = null;
|
|
if (ert->init2) {
|
|
cards[cardno].flags = 0;
|
|
cards[cardno].name = ert->name;
|
|
cards[cardno].initrc = ert->init2;
|
|
cards[cardno].rc = rc;
|
|
cards[cardno].zorro = zorro;
|
|
cards[cardno++].map = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}*/
|
|
|
|
this.reset = function() { //expamem_reset()
|
|
var do_mount = 1;
|
|
|
|
ecard = 0;
|
|
cardno = 0;
|
|
//cardid = currprefs.uae_hide ? commodore : hackers_id;
|
|
cardid = true ? commodore : hackers_id;
|
|
|
|
//chipdone = false;
|
|
|
|
allocate();
|
|
expamem_bank.name = "Autoconfig [reset]";
|
|
|
|
if (SAER.autoconf.need_uae_boot_rom() == 0)
|
|
do_mount = 0;
|
|
if (SAEV_AutoConf_boot_rom_type <= 0)
|
|
do_mount = 0;
|
|
|
|
/* check if Kickstart version is below 1.3 */
|
|
if (SAER.memory.ks12orolder() && do_mount) { //&& currprefs.uaeboard < 2) {
|
|
/*#if KS12_BOOT_HACK
|
|
do_mount = -1;
|
|
if (SAER.memory.ks11orolder()) {
|
|
filesys_start = 0xe90000;
|
|
SAER.memory.map_banks_z2(&filesys_bank, filesys_start >>> 16, 1);
|
|
expamem_init_filesys(0);
|
|
expamem_map_filesys_update();
|
|
}
|
|
#else*/
|
|
SAEF_log("expansion.reset() Kickstart version is below 1.3! Disabling automount devices.");
|
|
do_mount = 0;
|
|
//#endif
|
|
}
|
|
|
|
//add possible non-autoconfig boards
|
|
//add_expansions(BOARD_NONAUTOCONFIG_BEFORE);
|
|
|
|
var fastmem_after = false;
|
|
if (SAEV_config.memory.z2FastAutoConfig) {
|
|
//fastmem_after = add_fastram_after_expansion(BOARD_AUTOCONFIG_Z2);
|
|
if (!fastmem_after && fastmem_bank.baseaddr !== null && (fastmem_bank.allocated <= 262144 || SAEV_config.memory.chipSize <= 2 * 1024 * 1024)) {
|
|
cards[cardno].flags = 0;
|
|
cards[cardno].name = "Z2Fast";
|
|
cards[cardno].initnum = expamem_init_fastcard;
|
|
cards[cardno++].map = expamem_map_fastcard;
|
|
}
|
|
/*if (fastmem2_bank.baseaddr !== null && (fastmem2_bank.allocated <= 262144 || SAEV_config.memory.chipSize <= 2 * 1024 * 1024)) {
|
|
cards[cardno].flags = 0;
|
|
cards[cardno].name = "Z2Fast2";
|
|
cards[cardno].initnum = expamem_init_fastcard2;
|
|
cards[cardno++].map = expamem_map_fastcard2;
|
|
}*/
|
|
} else {
|
|
if (fastmem_bank.baseaddr !== null) {
|
|
fastmem_bank.name = "Fast memory (non-autoconfig)";
|
|
SAER_Memory_mapBanks(fastmem_bank, 0x00200000 >>> 16, fastmem_bank.allocated >>> 16, 0);
|
|
}
|
|
/*if (fastmem2_bank.baseaddr !== null) {
|
|
fastmem2_bank.name = "Fast memory 2 (non-autoconfig)";
|
|
SAER_Memory_mapBanks(fastmem2_bank, (0x00200000 + fastmem_bank.allocated) >>> 16, fastmem2_bank.allocated >>> 16, 0);
|
|
}*/
|
|
}
|
|
|
|
// immediately after Z2Fast so that they can be emulated as A590/A2091 with fast ram.
|
|
//add_expansions(BOARD_AUTOCONFIG_Z2);
|
|
//add_expansions(BOARD_NONAUTOCONFIG_AFTER_Z2);
|
|
|
|
/*if (fastmem_after && SAEV_config.memory.z2FastAutoConfig) {
|
|
if (fastmem_bank.baseaddr != null && (fastmem_bank.allocated <= 262144 || SAEV_config.memory.chipSize <= 2 * 1024 * 1024)) {
|
|
cards[cardno].flags = 0;
|
|
cards[cardno].name = "Z2Fast";
|
|
cards[cardno].initnum = expamem_init_fastcard;
|
|
cards[cardno++].map = expamem_map_fastcard;
|
|
}
|
|
}*/
|
|
|
|
/*#ifdef CDTV
|
|
if (currprefs.cs_cdtvcd && !currprefs.cs_cdtvcr) {
|
|
cards[cardno].flags = 0;
|
|
cards[cardno].name = "CDTV DMAC";
|
|
cards[cardno].initrc = cdtv_init;
|
|
cards[cardno++].map = null;
|
|
}
|
|
#endif
|
|
#ifdef CD32
|
|
if (currprefs.cs_cd32cd && SAEV_config.memory.z2FastSize == 0 && SAEV_config.memory.chipSize <= 0x200000 && currprefs.cs_cd32fmv) {
|
|
cards[cardno].flags = 0;
|
|
cards[cardno].name = "CD32MPEG";
|
|
cards[cardno].initnum = expamem_init_cd32fmv;
|
|
cards[cardno++].map = expamem_map_cd32fmv;
|
|
}
|
|
#endif
|
|
#ifdef A2065
|
|
if (currprefs.a2065name[0]) {
|
|
cards[cardno].flags = 0;
|
|
cards[cardno].name = "A2065";
|
|
cards[cardno].initnum = a2065_init;
|
|
cards[cardno++].map = null;
|
|
}
|
|
#endif
|
|
#ifdef FILESYS
|
|
if (do_mount && currprefs.uaeboard < 2) {
|
|
cards[cardno].flags = 0;
|
|
cards[cardno].name = "UAEFS";
|
|
cards[cardno].initnum = expamem_init_filesys;
|
|
cards[cardno++].map = expamem_map_filesys;
|
|
}
|
|
if (currprefs.uaeboard) {
|
|
cards[cardno].flags = 0;
|
|
cards[cardno].name = "UAEBOARD";
|
|
cards[cardno].initnum = expamem_init_uaeboard;
|
|
cards[cardno++].map = expamem_map_uaeboard;
|
|
}
|
|
#endif
|
|
#ifdef WITH_TOCCATA
|
|
if (currprefs.sound_toccata) {
|
|
cards[cardno].flags = 0;
|
|
cards[cardno].name = "Toccata";
|
|
cards[cardno++].initnum = sndboard_init;
|
|
}
|
|
#endif
|
|
if (currprefs.monitoremu == MONITOREMU_FIRECRACKER24) {
|
|
cards[cardno].flags = 0;
|
|
cards[cardno].name = "FireCracker24";
|
|
cards[cardno++].initnum = specialmonitor_autoconfig_init;
|
|
}*/
|
|
|
|
/* Z3 boards last */
|
|
if (!SAEV_config.cpu.addressSpace24) {
|
|
if (z3fastmem_bank.baseaddr !== null) {
|
|
var alwaysmapz3 = SAEV_config.memory.z3Mapping != SAEC_Config_Memory_z3Mapping_Real;
|
|
z3num = 0;
|
|
cards[cardno].flags = 2 | 1;
|
|
cards[cardno].name = "Z3Fast";
|
|
cards[cardno].initnum = expamem_init_z3fastmem;
|
|
cards[cardno++].map = expamem_map_z3fastmem;
|
|
if (alwaysmapz3 || expamem_z3hack(SAEV_config))
|
|
SAER.memory.map_banks_z3(z3fastmem_bank, z3fastmem_bank.start >>> 16, SAEV_config.memory.z3FastSize >>> 16);
|
|
|
|
/*if (z3fastmem2_bank.baseaddr != null) {
|
|
cards[cardno].flags = 2 | 1;
|
|
cards[cardno].name = "Z3Fast2";
|
|
cards[cardno].initnum = expamem_init_z3fastmem2;
|
|
cards[cardno++].map = expamem_map_z3fastmem2;
|
|
if (alwaysmapz3 || expamem_z3hack(SAEV_config))
|
|
SAER.memory.map_banks_z3(z3fastmem2_bank, z3fastmem2_bank.start >>> 16, currprefs.z3fastmem2_size >>> 16);
|
|
}*/
|
|
}
|
|
/*if (z3chipmem_bank.baseaddr != null)
|
|
SAER.memory.map_banks_z3(z3chipmem_bank, z3chipmem_bank.start >>> 16, currprefs.z3chipmem_size >>> 16);
|
|
|
|
add_expansions(BOARD_AUTOCONFIG_Z3);*/
|
|
}
|
|
|
|
//add_expansions(BOARD_NONAUTOCONFIG_AFTER_Z3);
|
|
|
|
expamem_z2_pointer = 0;
|
|
expamem_z3_pointer = 0;
|
|
expamem_z3_sum = 0;
|
|
|
|
if (cardno == 0)
|
|
expamem_init_clear_zero();
|
|
else
|
|
call_card_init(0);
|
|
}
|
|
|
|
this.setup = function() { //expansion_init()
|
|
fastmem_bank.allocated = 0;
|
|
fastmem_bank.mask = fastmem_bank.start = 0;
|
|
fastmem_bank.baseaddr = null;
|
|
/*fastmem_nojit_bank.allocated = 0;
|
|
fastmem_nojit_bank.mask = fastmem_nojit_bank.start = 0;
|
|
fastmem_nojit_bank.baseaddr = null;
|
|
|
|
fastmem2_bank.allocated = 0;
|
|
fastmem2_bank.mask = fastmem2_bank.start = 0;
|
|
fastmem2_bank.baseaddr = null;
|
|
fastmem2_nojit_bank.allocated = 0;
|
|
fastmem2_nojit_bank.mask = fastmem2_nojit_bank.start = 0;
|
|
fastmem2_nojit_bank.baseaddr = null;
|
|
|
|
z3fastmem_bank.allocated = 0;
|
|
z3fastmem_bank.mask = z3fastmem_bank.start = 0;
|
|
z3fastmem_bank.baseaddr = null;
|
|
|
|
z3fastmem2_bank.allocated = 0;
|
|
z3fastmem2_bank.mask = z3fastmem2_bank.start = 0;
|
|
z3fastmem2_bank.baseaddr = null;
|
|
|
|
z3chipmem_bank.allocated = 0;
|
|
z3chipmem_bank.mask = z3chipmem_bank.start = 0;
|
|
z3chipmem_bank.baseaddr = null;*/
|
|
|
|
/*#ifdef FILESYS
|
|
filesys_start = 0;
|
|
#endif*/
|
|
|
|
allocate();
|
|
|
|
/*#ifdef FILESYS
|
|
if (currprefs.uaeboard < 2) {
|
|
filesys_bank.allocated = 0x10000;
|
|
if (!mapped_malloc (&filesys_bank)) {
|
|
SAEF_error("virtual memory exhausted (filesysory)!");
|
|
exit(0);
|
|
}
|
|
}
|
|
#endif
|
|
if (currprefs.uaeboard) {
|
|
uaeboard_bank.allocated = 0x10000;
|
|
mapped_malloc(&uaeboard_bank);
|
|
}*/
|
|
}
|
|
|
|
this.cleanup = function() {
|
|
mapped_free(fastmem_bank);
|
|
/*mapped_free(fastmem2_bank);
|
|
mapped_free(z3fastmem_bank);
|
|
mapped_free(z3fastmem2_bank);
|
|
mapped_free(z3chipmem_bank);
|
|
|
|
fastmem_nojit_bank.baseaddr = null;
|
|
fastmem2_nojit_bank.baseaddr = null;*/
|
|
|
|
/*#ifdef FILESYS
|
|
mapped_free (&filesys_bank);
|
|
#endif
|
|
if (currprefs.uaeboard)
|
|
mapped_free(&uaeboard_bank);*/
|
|
}
|
|
|
|
function clear_bank(ab) {
|
|
if (ab.baseaddr !== null && ab.allocated) {
|
|
//memset(ab->baseaddr, 0, ab->allocated > 0x800000 ? 0x800000 : ab->allocated);
|
|
SAEF_memset(ab.baseaddr,0, 0, ab.allocated > 0x800000 ? 0x800000 : ab.allocated);
|
|
}
|
|
}
|
|
this.clear = function() { //expansion_clear()
|
|
clear_bank(fastmem_bank);
|
|
/*clear_bank(fastmem2_bank);
|
|
clear_bank(z3fastmem_bank);
|
|
clear_bank(z3fastmem2_bank);
|
|
clear_bank(z3chipmem_bank);*/
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/*-----------------------------------------------------------------------*/
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
/*var expamem_null = new SAEO_Memory_addrbank(
|
|
null, null, null,
|
|
null, null, null,
|
|
null, null, null, null, "",
|
|
null, null,
|
|
//0, 0, 0
|
|
0
|
|
);
|
|
var expamem_none = new SAEO_Memory_addrbank(
|
|
null, null, null,
|
|
null, null, null,
|
|
null, null, null, null, "",
|
|
null, null,
|
|
//0, 0, 0
|
|
0
|
|
);*/
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* BANK Autoconfig Z2 */
|
|
|
|
function expamem_get32(addr) {
|
|
if (expamem_bank_current && expamem_bank_current !== expamem_bank)
|
|
return expamem_bank_current.get32(addr);
|
|
SAEF_warn("expamem_get32() Z2 READ.L from address $%08x PC=%x", addr, SAER_CPU_getPC());
|
|
return ((expamem_get16(addr) << 16) | expamem_get16(addr + 2)) >>> 0;
|
|
}
|
|
function expamem_get16(addr) {
|
|
if (expamem_bank_current && expamem_bank_current !== expamem_bank)
|
|
return expamem_bank_current.get16(addr);
|
|
if (expamem_type() != zorroIII) {
|
|
if (expamem_bank_current && expamem_bank_current !== expamem_bank)
|
|
return expamem_bank_current.get8(addr) << 8;
|
|
}
|
|
SAEF_warn("expamem_get16() READ.W from address $%08x PC=%x", addr, SAER_CPU_getPC());
|
|
return (expamem_get8(addr) << 8) | expamem_get8(addr + 1);
|
|
}
|
|
function expamem_get8(addr) {
|
|
/*if (!chipdone) {
|
|
chipdone = true;
|
|
addextrachip(SAER_Memory_get32(4));
|
|
}*/
|
|
if (expamem_bank_current && expamem_bank_current !== expamem_bank)
|
|
return expamem_bank_current.get8(addr);
|
|
|
|
return expamem[addr & 0xffff];
|
|
/*addr &= 0xFFFF;
|
|
var b = expamem[addr];
|
|
#if EXP_DEBUG
|
|
SAEF_log("expamem_get8 %x %x", addr, b);
|
|
#endif
|
|
return b;*/
|
|
}
|
|
function expamem_put32(addr, value) {
|
|
if (expamem_bank_current && expamem_bank_current !== expamem_bank) {
|
|
expamem_bank_current.put32(addr, value);
|
|
return;
|
|
}
|
|
SAEF_warn("expamem_put32() Z2 WRITE.L to address $%08x : value $%08x", addr, value);
|
|
}
|
|
function expamem_put16(addr, value) {
|
|
/*#if EXP_DEBUG
|
|
SAEF_log("expamem_put16 %x %x", addr, value);
|
|
#endif*/
|
|
value &= 0xffff;
|
|
if (ecard >= cardno)
|
|
return;
|
|
if (expamem_type() != zorroIII)
|
|
SAEF_warn("expamem_put16() WRITE.W to address $%08x : value $%x PC=%08x", addr, value, SAER_CPU_getPC());
|
|
|
|
switch (addr & 0xff) {
|
|
case 0x48:
|
|
// A2630 boot rom writes WORDs to Z2 boards!
|
|
if (expamem_type() == zorroII) {
|
|
expamem_lo = 0;
|
|
expamem_hi = (value >> 8) & 0xff;
|
|
expamem_z2_pointer = (expamem_hi | (expamem_lo >> 4)) << 16;
|
|
expamem_board_pointer = expamem_z2_pointer;
|
|
if (cards[ecard].map) {
|
|
expamem_next(cards[ecard].map(), null);
|
|
return;
|
|
}
|
|
if (expamem_bank_current && expamem_bank_current !== expamem_bank) {
|
|
expamem_bank_current.put8(addr, value >> 8);
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
case 0x44:
|
|
if (expamem_type() == zorroIII) {
|
|
expamem_hi = value & 0xff00;
|
|
var addr = ((expamem_hi | (expamem_lo >> 4)) << 16) >>> 0;
|
|
if (!expamem_z3hack(SAEV_config))
|
|
expamem_z3_pointer = addr;
|
|
else {
|
|
if (addr != expamem_z3_pointer) {
|
|
SAEF_warn("expansion.expamem_put16() hack %08x %08x", addr, expamem_z3_pointer);
|
|
SAER_Memory_put16(SAER_CPU_regs.a[3] + 0x20, expamem_z3_pointer >>> 16); //ATT regs.regs[11]
|
|
SAER_Memory_put16(SAER_CPU_regs.a[3] + 0x28, expamem_z3_pointer >>> 16);
|
|
}
|
|
}
|
|
expamem_board_pointer = expamem_z3_pointer;
|
|
}
|
|
if (cards[ecard].map) {
|
|
expamem_next(cards[ecard].map(), null);
|
|
return;
|
|
}
|
|
break;
|
|
case 0x4c:
|
|
if (cards[ecard].map) {
|
|
expamem_next(null, null);
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
if (expamem_bank_current && expamem_bank_current !== expamem_bank)
|
|
expamem_bank_current.put16(addr, value);
|
|
}
|
|
function expamem_put8(addr, value) {
|
|
/*#if EXP_DEBUG
|
|
SAEF_log("expamem_put8 %x %x", addr, value);
|
|
#endif*/
|
|
value &= 0xff;
|
|
if (ecard >= cardno)
|
|
return;
|
|
if (expamem_type() == protoautoconfig) {
|
|
switch (addr & 0xff) {
|
|
case 0x22: {
|
|
expamem_hi = value & 0x7f;
|
|
expamem_z2_pointer = 0xe80000 | (expamem_hi * 4096);
|
|
expamem_board_pointer = expamem_z2_pointer;
|
|
if (cards[ecard].map) {
|
|
expamem_next(cards[ecard].map(), null);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
switch (addr & 0xff) {
|
|
case 0x48:
|
|
if (expamem_type() == zorroII) {
|
|
expamem_hi = value & 0xff;
|
|
expamem_z2_pointer = (expamem_hi | (expamem_lo >> 4)) << 16;
|
|
expamem_board_pointer = expamem_z2_pointer;
|
|
if (cards[ecard].map) {
|
|
expamem_next(cards[ecard].map(), null);
|
|
return;
|
|
}
|
|
} else {
|
|
expamem_lo = value & 0xff;
|
|
}
|
|
break;
|
|
|
|
case 0x4a:
|
|
if (expamem_type() == zorroII)
|
|
expamem_lo = value & 0xff;
|
|
break;
|
|
|
|
case 0x4c:
|
|
if (cards[ecard].map) {
|
|
expamem_next(expamem_bank_current, null);
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (expamem_bank_current && expamem_bank_current !== expamem_bank)
|
|
expamem_bank_current.put8(addr, value);
|
|
}
|
|
|
|
var expamem_bank = new SAEO_Memory_addrbank(
|
|
expamem_get32, expamem_get16, expamem_get8,
|
|
expamem_put32, expamem_put16, expamem_put8,
|
|
SAEF_Memory_defaultXLate, SAEF_Memory_defaultCheck, null, null, "Autoconfig Z2",
|
|
SAEF_Memory_dummyGetInst32, SAEF_Memory_dummyGetInst16,
|
|
//SAEC_Memory_addrbank_flag_IO | SAEC_Memory_addrbank_flag_SAFE | SAEC_Memory_addrbank_flag_PPCIOSPACE, S_READ, S_WRITE
|
|
SAEC_Memory_addrbank_flag_IO | SAEC_Memory_addrbank_flag_SAFE | SAEC_Memory_addrbank_flag_PPCIOSPACE
|
|
);
|
|
SAER_Expansion_expamem_bank = expamem_bank;
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* BANK Autoconfig Z3 */
|
|
|
|
function expamemz3_get8(addr) {
|
|
if (!expamem_bank_current)
|
|
return 0;
|
|
var reg = addr & 0xff;
|
|
if (addr & 0x100)
|
|
reg += 2;
|
|
return expamem_bank_current.get8(reg);
|
|
}
|
|
function expamemz3_get16(addr) {
|
|
SAEF_warn("expansion.expamemz3_get16() READ.W from address $%08x PC=%x", addr, SAER_CPU_getPC());
|
|
return (expamemz3_get8(addr) << 8) | expamemz3_get8(addr + 1);
|
|
}
|
|
function expamemz3_get32(addr) {
|
|
SAEF_warn("expansion.expamemz3_get32() READ.L from address $%08x PC=%x", addr, SAER_CPU_getPC());
|
|
return ((expamemz3_get16(addr) << 16) | expamemz3_get16(addr + 2)) >>> 0;
|
|
}
|
|
function expamemz3_put8(addr, value) {
|
|
if (!expamem_bank_current)
|
|
return;
|
|
var reg = addr & 0xff;
|
|
if (addr & 0x100)
|
|
reg += 2;
|
|
if (reg == 0x48) {
|
|
if (expamem_type() == zorroII) {
|
|
expamem_hi = value & 0xff;
|
|
expamem_z2_pointer = ((expamem_hi | (expamem_lo >> 4)) << 16) >>> 0;
|
|
expamem_board_pointer = expamem_z2_pointer;
|
|
} else {
|
|
expamem_lo = value & 0xff;
|
|
}
|
|
} else if (reg == 0x4a) {
|
|
if (expamem_type() == zorroII)
|
|
expamem_lo = value & 0xff;
|
|
}
|
|
expamem_bank_current.put8(reg, value);
|
|
}
|
|
function expamemz3_put16(addr, value) {
|
|
if (!expamem_bank_current)
|
|
return;
|
|
var reg = addr & 0xff;
|
|
if (addr & 0x100)
|
|
reg += 2;
|
|
if (reg == 0x44) {
|
|
if (expamem_type() == zorroIII) {
|
|
expamem_hi = value & 0xff00;
|
|
var z3_pointer = ((expamem_hi | (expamem_lo >> 4)) << 16) >>> 0;
|
|
if (!expamem_z3hack(SAEV_config))
|
|
expamem_z3_pointer = z3_pointer;
|
|
else {
|
|
if (z3_pointer != expamem_z3_pointer) {
|
|
SAEF_warn("expansion.expamemz3_put16() hack %08x %08x", addr, expamem_z3_pointer);
|
|
SAER_Memory_put16(SAER_CPU_regs.a[3] + 0x20, expamem_z3_pointer >>> 16); //ATT regs.regs[11]
|
|
SAER_Memory_put16(SAER_CPU_regs.a[3] + 0x28, expamem_z3_pointer >>> 16);
|
|
}
|
|
}
|
|
expamem_board_pointer = expamem_z3_pointer;
|
|
}
|
|
}
|
|
expamem_bank_current.put16(reg, value);
|
|
}
|
|
function expamemz3_put32(addr, value) {
|
|
SAEF_warn("expansion.expamemz3_put32() WRITE.L to address $%08x, value $%08x", addr, value);
|
|
}
|
|
var expamemz3_bank = new SAEO_Memory_addrbank(
|
|
expamemz3_get32, expamemz3_get16, expamemz3_get8,
|
|
expamemz3_put32, expamemz3_put16, expamemz3_put8,
|
|
SAEF_Memory_defaultXLate, SAEF_Memory_defaultCheck, null, null, "Autoconfig Z3",
|
|
SAEF_Memory_dummyGetInst32, SAEF_Memory_dummyGetInst16,
|
|
//SAEC_Memory_addrbank_flag_IO | SAEC_Memory_addrbank_flag_SAFE | SAEC_Memory_addrbank_flag_PPCIOSPACE, S_READ, S_WRITE
|
|
SAEC_Memory_addrbank_flag_IO | SAEC_Memory_addrbank_flag_SAFE | SAEC_Memory_addrbank_flag_PPCIOSPACE
|
|
);
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
/*#ifdef CD32
|
|
static addrbank *expamem_map_cd32fmv (void) {
|
|
return cd32_fmv_init (expamem_z2_pointer);
|
|
}
|
|
static addrbank *expamem_init_cd32fmv (int devnum) {
|
|
int ids[] = { 23, -1 };
|
|
struct romlist *rl = getromlistbyids (ids, NULL);
|
|
struct romdata *rd;
|
|
struct zfile *z;
|
|
|
|
expamem_init_clear ();
|
|
if (!rl)
|
|
return NULL;
|
|
write_log (_T("CD32 FMV ROM '%s' %d.%d\n"), rl->path, rl->rd->ver, rl->rd->rev);
|
|
rd = rl->rd;
|
|
z = read_rom (rd);
|
|
if (z) {
|
|
zfile_fread (expamem, 128, 1, z);
|
|
zfile_fclose (z);
|
|
}
|
|
return NULL;
|
|
}
|
|
#endif*/
|
|
}
|