src/mess/machine/hp48.c
| r1875 | r1876 | |
| 19 | 19 | 13437 |
| 20 | 20 | */ |
| 21 | 21 | |
| 22 | enum { |
| 23 | HP48_ROM, |
| 24 | HP48_CARD1, |
| 25 | HP48_CARD2, |
| 26 | HP48_RAM, |
| 27 | HP48_HDW, |
| 28 | HP48_END |
| 29 | }; |
| 22 | 30 | |
| 23 | 31 | |
| 24 | 32 | |
| r1875 | r1876 | |
| 52 | 60 | } |
| 53 | 61 | }; |
| 54 | 62 | |
| 63 | static struct { |
| 64 | UINT8 *base; |
| 65 | UINT8 type; |
| 66 | } hp48_banks[129]; |
| 67 | |
| 55 | 68 | // to do support weired comparator settings |
| 56 | 69 | static void hp48_config(void) |
| 57 | 70 | { |
| 58 | | int begin, end; |
| 71 | static const read8_handler read_handlers[11] = { 0, MRA8_BANK1, MRA8_BANK2, MRA8_BANK3, MRA8_BANK4, MRA8_BANK5, MRA8_BANK6, MRA8_BANK7, MRA8_BANK8, MRA8_BANK9, MRA8_BANK10 }; |
| 72 | int i, begin_bank, end_bank, begin, end, mem_type, bank; |
| 59 | 73 | |
| 60 | | // lowest priority first |
| 61 | | memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0, 0xfffff, 0, 0, MRA8_ROM); |
| 62 | | memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, 0, 0xfffff, 0, 0, MWA8_NOP); |
| 63 | | if (hp48s.mem[CARD1].adr!=-1) |
| 64 | | { |
| 65 | | begin=hp48s.mem[CARD1].adr&hp48s.mem[CARD1].size&~0xfff; |
| 66 | | end=begin|(hp48s.mem[CARD1].size^0xff000)|0xfff; |
| 67 | | if (end!=begin) |
| 68 | | { |
| 69 | | memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, begin, end, 0, 0, MRA8_BANK1); |
| 70 | | memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, begin, end, 0, 0, MWA8_BANK1); |
| 71 | | memory_set_bankptr(1, hp48_card1); |
| 74 | /* Determine the current memory map */ |
| 75 | |
| 76 | /* Lowest priority is ROM */ |
| 77 | for ( i = 0; i < 128; i++ ) { |
| 78 | hp48_banks[i].base = memory_region( REGION_CPU1 ) + i * 0x2000; |
| 79 | hp48_banks[i].type = HP48_ROM; |
| 80 | } |
| 81 | hp48_banks[128].type = HP48_END; |
| 82 | |
| 83 | /* Next priority is CARD1 */ |
| 84 | if ( hp48s.mem[CARD1].adr != -1 ) { |
| 85 | logerror("hp48_config CARD1 should be configured\n"); |
| 86 | begin_bank = ( ( hp48s.mem[CARD1].adr & ~( hp48s.mem[CARD1].size - 1 ) ) >> 13 ) & 0x7F; |
| 87 | end_bank = begin_bank | ( ( hp48s.mem[CARD1].size - 1 ) >> 13 ); |
| 88 | for ( i = begin_bank; i <= end_bank; i++ ) { |
| 89 | hp48_banks[i].base = hp48_card1 + i * 0x2000; |
| 90 | hp48_banks[i].type = HP48_CARD1; |
| 72 | 91 | } |
| 92 | logerror("CARD1 begin = %02X, end = %02X\n", begin_bank, end_bank); |
| 73 | 93 | } |
| 74 | | if (hp48s.mem[CARD2].adr!=-1) { |
| 75 | | begin=hp48s.mem[CARD2].adr&hp48s.mem[CARD2].size&~0xfff; |
| 76 | | end=begin|(hp48s.mem[CARD2].size^0xff000)|0xfff; |
| 77 | | if (end!=begin) { |
| 78 | | memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, begin, end, 0, 0, MRA8_BANK2); |
| 79 | | memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, begin, end, 0, 0, MWA8_BANK2); |
| 80 | | memory_set_bankptr(2, hp48_card2); |
| 94 | |
| 95 | /* Next priority is CARD2 */ |
| 96 | if ( hp48s.mem[CARD2].adr != -1 ) { |
| 97 | logerror("hp48_config CARD2 should be configured\n"); |
| 98 | begin_bank = ( ( hp48s.mem[CARD2].adr & ~( hp48s.mem[CARD2].size - 1 ) ) >> 13 ) & 0x7F; |
| 99 | end_bank = begin_bank | ( ( hp48s.mem[CARD2].size - 1 ) >> 13 ); |
| 100 | for ( i = begin_bank; i <= end_bank; i++ ) { |
| 101 | hp48_banks[i].base = hp48_card2 + i * 0x2000; |
| 102 | hp48_banks[i].type = HP48_CARD2; |
| 81 | 103 | } |
| 104 | logerror("CARD2 begin = %02X, end = %02X\n", begin_bank, end_bank); |
| 82 | 105 | } |
| 83 | | if (hp48s.mem[RAM].adr!=-1) { |
| 84 | | begin=hp48s.mem[RAM].adr&hp48s.mem[RAM].size&~0xfff; |
| 85 | | end=begin|(hp48s.mem[RAM].size^0xff000)|0xfff; |
| 86 | | if (end!=begin) { |
| 87 | | memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, begin, end, 0, 0, MRA8_BANK3); |
| 88 | | memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, begin, end, 0, 0, MWA8_BANK3); |
| 89 | | memory_set_bankptr(3, hp48_ram); |
| 106 | |
| 107 | /* Next priority is RAM */ |
| 108 | if ( hp48s.mem[RAM].adr != -1 ) { |
| 109 | logerror("hp48_config RAM should be configured\n"); |
| 110 | begin_bank = ( ( hp48s.mem[RAM].adr & ~( hp48s.mem[RAM].size - 1 ) ) >> 13 ) & 0x7F; |
| 111 | end_bank = begin_bank | ( ( hp48s.mem[RAM].size - 1 ) >> 13 ); |
| 112 | for ( i = begin_bank; i <= end_bank; i++ ) { |
| 113 | hp48_banks[i].base = hp48_ram + i * 0x2000; |
| 114 | hp48_banks[i].type = HP48_RAM; |
| 90 | 115 | } |
| 116 | logerror("RAM begin = %02X, end = %02X\n", begin_bank, end_bank); |
| 91 | 117 | } |
| 92 | | if (hp48s.mem[HDW].adr!=-1) |
| 93 | | { |
| 118 | |
| 119 | /* Highest priority is HDW */ |
| 120 | |
| 121 | /* Set up dynamic bank configuration */ |
| 122 | bank = 1; |
| 123 | begin_bank = end_bank = 0; |
| 124 | mem_type = hp48_banks[begin_bank].type; |
| 125 | for ( i = 1; i < 129; i++ ) { |
| 126 | if ( hp48_banks[i].type != mem_type ) { |
| 127 | begin = begin_bank << 13; |
| 128 | end = ( end_bank << 13 ) | 0x1FFF; |
| 129 | |
| 130 | memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, begin, end, 0, 0, read_handlers[bank] ); |
| 131 | memory_set_bankptr( bank, hp48_banks[begin_bank].base ); |
| 132 | |
| 133 | bank++; |
| 134 | begin_bank = i; |
| 135 | mem_type = hp48_banks[i].type; |
| 136 | } |
| 137 | end_bank = i; |
| 138 | } |
| 139 | |
| 140 | if ( hp48s.mem[HDW].adr != -1 ) { |
| 94 | 141 | memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, hp48s.mem[HDW].adr&~0x3f, |
| 95 | 142 | hp48s.mem[HDW].adr|0x3f, 0, 0, hp48_read); |
| 96 | | memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, hp48s.mem[HDW].adr&~0x3f, |
| 97 | | hp48s.mem[HDW].adr|0x3f, 0, 0, hp48_write); |
| 143 | // memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, hp48s.mem[HDW].adr&~0x3f, |
| 144 | // hp48s.mem[HDW].adr|0x3f, 0, 0, hp48_write); |
| 98 | 145 | } |
| 99 | | memory_set_context(0); |
| 100 | 146 | } |
| 101 | 147 | |
| 148 | WRITE8_HANDLER( hp48_mem_w ) { |
| 149 | int bank = ( offset >> 13 ) & 0x7F; |
| 150 | //logerror("hp48_mem_w: offset = %06X, data = %02X\n", offset, data ); |
| 151 | |
| 152 | /* Check for write to HDW */ |
| 153 | if ( hp48s.mem[HDW].adr != -1 && offset >= hp48s.mem[HDW].adr && offset < hp48s.mem[HDW].adr + 0x40 ) { |
| 154 | hp48_write( offset & 0x3F, data ); |
| 155 | } else { |
| 156 | switch( hp48_banks[bank].type ) { |
| 157 | case HP48_RAM: |
| 158 | //logerror("RAM write\n"); |
| 159 | hp48_banks[bank].base[offset & 0x1FFF] = data; |
| 160 | break; |
| 161 | case HP48_CARD1: |
| 162 | //logerror("CARD1 write\n"); |
| 163 | hp48_banks[bank].base[offset & 0x1FFF] = data; |
| 164 | break; |
| 165 | case HP48_CARD2: |
| 166 | //logerror("CARD2 write\n"); |
| 167 | hp48_banks[bank].base[offset & 0x1FFF] = data; |
| 168 | break; |
| 169 | } |
| 170 | } |
| 171 | } |
| 172 | |
| 102 | 173 | /* priority on the bus |
| 103 | 174 | hdw, ram, ce2, ce1, nce3, rom */ |
| 104 | 175 | void hp48_mem_reset(void) |
| r1875 | r1876 | |
| 114 | 185 | |
| 115 | 186 | void hp48_mem_config(int v) |
| 116 | 187 | { |
| 188 | logerror("hp48_mem_config called\n"); |
| 117 | 189 | if (hp48s.mem[HDW].adr==-1) { |
| 190 | logerror("Configuring HDW at %06X\n", v ); |
| 118 | 191 | hp48s.mem[HDW].adr=v; |
| 119 | 192 | hp48_config(); |
| 120 | 193 | } else if (hp48s.mem[RAM].adr==-1) { |
| 121 | 194 | if (hp48s.state==0) { |
| 195 | v = 0x100000 - v; |
| 122 | 196 | hp48s.mem[RAM].size=v; |
| 197 | logerror("Setting RAM size to %06X\n", v ); |
| 123 | 198 | hp48s.state++; |
| 124 | 199 | } else { |
| 200 | logerror("Configuring RAM at %06X\n", v ); |
| 125 | 201 | hp48s.mem[RAM].adr=v; |
| 126 | 202 | hp48s.state=0; |
| 127 | 203 | hp48_config(); |
| 128 | 204 | } |
| 129 | 205 | } else if (hp48s.mem[CARD1].adr==-1) { |
| 130 | 206 | if (hp48s.state==0) { |
| 207 | v = 0x100000 - v; |
| 131 | 208 | hp48s.mem[CARD1].size=v; |
| 132 | 209 | hp48s.state++; |
| 133 | 210 | } else { |
| 211 | logerror("Configuring CARD1 at %06X\n", v ); |
| 134 | 212 | hp48s.mem[CARD1].adr=v; |
| 135 | 213 | hp48s.state=0; |
| 136 | 214 | hp48_config(); |
| 137 | 215 | } |
| 138 | | } else if (hp48s.mem[CARD1].adr==-1) { |
| 216 | } else if (hp48s.mem[CARD2].adr==-1) { |
| 139 | 217 | if (hp48s.state==0) { |
| 218 | v = 0x100000 - v; |
| 140 | 219 | hp48s.mem[CARD2].size=v; |
| 141 | 220 | hp48s.state++; |
| 142 | 221 | } else { |
| 222 | logerror("Configuring CARD2 at %06X\n", v ); |
| 143 | 223 | hp48s.mem[CARD2].adr=v; |
| 144 | 224 | hp48s.state=0; |
| 145 | 225 | hp48_config(); |