src/mess/drivers/ti89.c
| r9621 | r9622 | |
| 1 | 1 | /*************************************************************************** |
| 2 | 2 | |
| 3 | | TI-89, TI-92 and TI-92 plus driver by Sandro Ronco |
| 3 | TI-89, TI-92, TI-92 plus, Voyage 200 PLT and TI-89 Titanium |
| 4 | 4 | |
| 5 | | NVRAM works only if the calculator is turned off (2nd + ON) before closing of MESS |
| 5 | Driver by Sandro Ronco |
| 6 | 6 | |
| 7 | Note: |
| 8 | -NVRAM works only if the calculator is turned off (2nd + ON) before closing MESS |
| 9 | |
| 7 | 10 | TODO: |
| 8 | 11 | -Link |
| 9 | 12 | -HW 3 I/O port |
| 10 | 13 | -RTC |
| 11 | 14 | -LCD contrast |
| 15 | |
| 12 | 16 | ****************************************************************************/ |
| 13 | 17 | |
| 18 | #define ADDRESS_MAP_MODERN |
| 19 | |
| 14 | 20 | #include "emu.h" |
| 15 | 21 | #include "cpu/m68000/m68000.h" |
| 16 | 22 | #include "includes/ti89.h" |
| 23 | #include "machine/nvram.h" |
| 24 | #include "machine/intelfsh.h" |
| 17 | 25 | |
| 18 | | static UINT8 ti_68k_keypad_r (running_machine *machine); |
| 19 | 26 | |
| 20 | | class t68k_state : public driver_device |
| 27 | UINT8 ti68k_state::keypad_r (running_machine *machine) |
| 21 | 28 | { |
| 22 | | public: |
| 23 | | t68k_state(running_machine &machine, const driver_device_config_base &config) |
| 24 | | : driver_device(machine, config) { } |
| 25 | | |
| 26 | | /* HW specifications */ |
| 27 | | UINT8 hw_version; |
| 28 | | UINT8 mem_type; |
| 29 | | UINT32 initial_pc; |
| 30 | | UINT16 *ram; |
| 31 | | UINT32 ram_size; |
| 32 | | |
| 33 | | /* keyboard */ |
| 34 | | UINT16 kb_mask; |
| 35 | | UINT8 on_key; |
| 36 | | |
| 37 | | /* LCD */ |
| 38 | | UINT8 lcd_on; |
| 39 | | UINT32 lcd_base; |
| 40 | | UINT8 lcd_width; |
| 41 | | UINT8 lcd_height; |
| 42 | | UINT8 lcd_contrast; |
| 43 | | |
| 44 | | /* Flash */ |
| 45 | | UINT8 flash_protect; |
| 46 | | UINT8 flash_state; |
| 47 | | UINT8 flash_wait; |
| 48 | | UINT8 flash_ready; |
| 49 | | |
| 50 | | /* I/O */ |
| 51 | | UINT16 io_hw1[0x10]; |
| 52 | | UINT16 io_hw2[0x80]; |
| 53 | | |
| 54 | | /* Timer */ |
| 55 | | UINT8 timer_on; |
| 56 | | UINT8 timer_val; |
| 57 | | UINT16 timer_mask; |
| 58 | | }; |
| 59 | | |
| 60 | | |
| 61 | | static UINT8 ti_68k_keypad_r (running_machine *machine) |
| 62 | | { |
| 63 | | t68k_state *state = machine->driver_data<t68k_state>(); |
| 64 | 29 | UINT8 port, bit, data = 0xff; |
| 65 | 30 | static const char *const bitnames[] = {"BIT0", "BIT1", "BIT2", "BIT3", "BIT4", "BIT5", "BIT6", "BIT7"}; |
| 66 | 31 | |
| 67 | 32 | for (bit = 0; bit < 10; bit++) |
| 68 | | if (~state->kb_mask & (0x01 << bit)) |
| 33 | if (~m_kb_mask & (0x01 << bit)) |
| 69 | 34 | for (port = 0; port < 8; port++) |
| 70 | 35 | data ^= input_port_read(machine, bitnames[port]) & (0x01 << bit) ? 0x01 << port : 0x00; |
| 71 | 36 | return data; |
| 72 | 37 | } |
| 73 | 38 | |
| 74 | 39 | |
| 75 | | WRITE16_HANDLER ( ti68k_io_w ) |
| 40 | WRITE16_MEMBER ( ti68k_state::ti68k_io_w ) |
| 76 | 41 | { |
| 77 | | t68k_state *state = space->machine->driver_data<t68k_state>(); |
| 78 | | |
| 79 | 42 | switch(offset & 0x0f) |
| 80 | 43 | { |
| 81 | 44 | case 0x00: |
| 82 | | state->lcd_contrast=(state->lcd_contrast & 0xfe) | BIT(data, 5); |
| 45 | m_lcd_contrast = (m_lcd_contrast & 0xfe) | BIT(data, 5); |
| 83 | 46 | break; |
| 84 | 47 | case 0x02: |
| 85 | | if (!(data & 0x10) && data != state->io_hw1[offset]) |
| 86 | | space->machine->device<cpu_device>("maincpu")->suspend(SUSPEND_REASON_DISABLE, 1); |
| 48 | if (!(data & 0x10) && data != m_io_hw1[offset]) |
| 49 | m_maincpu->suspend(SUSPEND_REASON_DISABLE, 1); |
| 87 | 50 | break; |
| 88 | 51 | case 0x08: |
| 89 | | state->lcd_base = data << 3; |
| 52 | m_lcd_base = data << 3; |
| 90 | 53 | break; |
| 91 | 54 | case 0x09: |
| 92 | | state->lcd_width = (0x40 - ((data >> 8) & 0xff)) * 0x10; |
| 93 | | state->lcd_height = 0x100 - (data & 0xff); |
| 55 | m_lcd_width = (0x40 - ((data >> 8) & 0xff)) * 0x10; |
| 56 | m_lcd_height = 0x100 - (data & 0xff); |
| 94 | 57 | break; |
| 95 | 58 | case 0x0a: |
| 96 | | state->timer_on = BIT(data ,1); |
| 59 | m_timer_on = BIT(data ,1); |
| 97 | 60 | switch((data >> 4) & 0x03) |
| 98 | 61 | { |
| 99 | | case 0: state->timer_mask = 0x0000; break; |
| 100 | | case 1: state->timer_mask = 0x000f; break; |
| 101 | | case 2: state->timer_mask = 0x007f; break; |
| 102 | | case 3: state->timer_mask = 0x1fff; break; |
| 62 | case 0: m_timer_mask = 0x0000; break; |
| 63 | case 1: m_timer_mask = 0x000f; break; |
| 64 | case 2: m_timer_mask = 0x007f; break; |
| 65 | case 3: m_timer_mask = 0x1fff; break; |
| 103 | 66 | } |
| 104 | 67 | break; |
| 105 | 68 | case 0x0b: |
| 106 | | state->timer_val = data & 0xff; |
| 69 | m_timer_val = data & 0xff; |
| 107 | 70 | case 0x0c: |
| 108 | | state->kb_mask = data & 0x03ff; |
| 71 | m_kb_mask = data & 0x03ff; |
| 109 | 72 | break; |
| 110 | 73 | case 0x0e: |
| 111 | | state->lcd_on = (((data >> 8) & 0x3c) == 0x3c) ? 0 : 1; |
| 112 | | state->lcd_contrast = (state->lcd_contrast & 0x01) | ((data & 0x0f) << 1); |
| 74 | m_lcd_on = (((data >> 8) & 0x3c) == 0x3c) ? 0 : 1; |
| 75 | m_lcd_contrast = (m_lcd_contrast & 0x01) | ((data & 0x0f) << 1); |
| 113 | 76 | break; |
| 114 | 77 | default: break; |
| 115 | 78 | } |
| 116 | | state->io_hw1[offset & 0x0f] = data; |
| 79 | m_io_hw1[offset & 0x0f] = data; |
| 117 | 80 | } |
| 118 | 81 | |
| 119 | 82 | |
| 120 | | READ16_HANDLER ( ti68k_io_r ) |
| 83 | READ16_MEMBER ( ti68k_state::ti68k_io_r ) |
| 121 | 84 | { |
| 122 | | t68k_state *state = space->machine->driver_data<t68k_state>(); |
| 123 | 85 | UINT16 data; |
| 124 | 86 | |
| 125 | 87 | switch (offset & 0x0f) |
| 126 | 88 | { |
| 127 | 89 | case 0x00: |
| 128 | | data = 0x0400 | ((state->lcd_contrast & 1) << 13); |
| 90 | data = 0x0400 | ((m_lcd_contrast & 1) << 13); |
| 129 | 91 | break; |
| 130 | 92 | case 0x0b: |
| 131 | | data = state->timer_val; |
| 93 | data = m_timer_val; |
| 132 | 94 | break; |
| 133 | 95 | case 0x0d: |
| 134 | | data = ((!state->on_key) << 9) | ti_68k_keypad_r(space->machine); |
| 96 | data = ((!m_on_key) << 9) | keypad_r(space.machine); |
| 135 | 97 | break; |
| 136 | 98 | default: |
| 137 | | data= state->io_hw1[offset & 0x0f]; |
| 99 | data= m_io_hw1[offset & 0x0f]; |
| 138 | 100 | } |
| 139 | 101 | return data; |
| 140 | 102 | } |
| 141 | 103 | |
| 142 | 104 | |
| 143 | | WRITE16_HANDLER ( ti68k_io2_w ) |
| 105 | WRITE16_MEMBER ( ti68k_state::ti68k_io2_w ) |
| 144 | 106 | { |
| 145 | | t68k_state *state = space->machine->driver_data<t68k_state>(); |
| 146 | 107 | switch(offset & 0x7f) |
| 147 | 108 | { |
| 148 | 109 | case 0x0b: |
| 149 | | state->lcd_base = 0x4c00 + 0x1000 * (data & 0x03); |
| 110 | m_lcd_base = 0x4c00 + 0x1000 * (data & 0x03); |
| 150 | 111 | break; |
| 151 | 112 | case 0x0e: |
| 152 | | state->lcd_on = (data & 0x02) ? 1 : 0; |
| 113 | m_lcd_on = (data & 0x02) ? 1 : 0; |
| 153 | 114 | break; |
| 154 | 115 | default: break; |
| 155 | 116 | } |
| 156 | | state->io_hw2[offset & 0x7f] = data; |
| 117 | m_io_hw2[offset & 0x7f] = data; |
| 157 | 118 | } |
| 158 | 119 | |
| 159 | 120 | |
| 160 | | READ16_HANDLER ( ti68k_io2_r ) |
| 121 | READ16_MEMBER ( ti68k_state::ti68k_io2_r ) |
| 161 | 122 | { |
| 162 | | t68k_state *state = space->machine->driver_data<t68k_state>(); |
| 163 | 123 | UINT16 data; |
| 164 | 124 | |
| 165 | 125 | switch (offset & 0x7f) |
| 166 | 126 | { |
| 167 | 127 | default: |
| 168 | | data= state->io_hw2[offset & 0x7f]; |
| 128 | data= m_io_hw2[offset & 0x7f]; |
| 169 | 129 | } |
| 170 | 130 | return data; |
| 171 | 131 | } |
| 172 | 132 | |
| 173 | 133 | |
| 174 | | static WRITE16_HANDLER ( flash_w ) |
| 134 | WRITE16_MEMBER ( ti68k_state::flash_w ) |
| 175 | 135 | { |
| 176 | | t68k_state *state = space->machine->driver_data<t68k_state>(); |
| 177 | | UINT16 *flash_base = (UINT16 *)memory_region(space->machine, "maincpu"); |
| 178 | | |
| 179 | | /* verification if it is flash memory */ |
| 180 | | if (state->mem_type != FLASH) |
| 181 | | return; |
| 182 | | |
| 183 | | if (state->flash_ready) |
| 184 | | { |
| 185 | | flash_base[offset] &= data; |
| 186 | | state->flash_ready = 0; |
| 187 | | state->flash_wait = 1; |
| 188 | | } |
| 189 | | else if (data == 0x5050) |
| 190 | | state->flash_state = 0x50; |
| 191 | | else if (data == 0x1010) |
| 192 | | { |
| 193 | | state->flash_ready = 1; |
| 194 | | state->flash_state = 0x50; |
| 195 | | } |
| 196 | | else if (data == 0x2020 && state->flash_state == 0x50) |
| 197 | | state->flash_state = 0x20; |
| 198 | | else if (data == 0xd0d0 && state->flash_state == 0x20) |
| 199 | | { |
| 200 | | state->flash_state = 0xd0; |
| 201 | | state->flash_wait = 1; |
| 202 | | memset(&flash_base[offset & 0xff0000], 0xff, 64 * 1024); |
| 203 | | } |
| 204 | | else if (data == 0xffff && state->flash_state == 0x50) |
| 205 | | { |
| 206 | | state->flash_ready = 0; |
| 207 | | state->flash_wait = 0; |
| 208 | | } |
| 209 | | else if (data == 0x9090) |
| 210 | | state->flash_state = 0x90; |
| 136 | // verification if it is flash memory |
| 137 | if (m_flash_mem) |
| 138 | m_flash->write(offset, data); |
| 211 | 139 | } |
| 212 | 140 | |
| 213 | | |
| 214 | | static READ16_HANDLER ( rom_r ) |
| 141 | READ16_MEMBER ( ti68k_state::flash_r ) |
| 215 | 142 | { |
| 216 | | t68k_state *state = space->machine->driver_data<t68k_state>(); |
| 217 | | UINT16 *rom_base = (UINT16 *)memory_region(space->machine, "maincpu"); |
| 218 | | |
| 219 | | if (state->mem_type == FLASH) |
| 143 | if (m_flash_mem) |
| 220 | 144 | { |
| 221 | | if (state->flash_state == 0x90 ) |
| 222 | | switch(offset & 0xffff) |
| 223 | | { |
| 224 | | case 0: |
| 225 | | return 0x8900; |
| 226 | | case 2: |
| 227 | | return 0xb500; |
| 228 | | default: |
| 229 | | return 0xffff; |
| 230 | | } |
| 231 | | else if (state->flash_wait) |
| 232 | | return 0xffff; |
| 233 | | else |
| 234 | | return rom_base[offset]; |
| 145 | return m_flash->read(offset); |
| 235 | 146 | } |
| 236 | 147 | else |
| 148 | { |
| 149 | UINT16 *rom_base = (UINT16 *)memory_region(space.machine, "flash"); |
| 150 | |
| 237 | 151 | return rom_base[offset]; |
| 152 | } |
| 238 | 153 | } |
| 239 | 154 | |
| 240 | 155 | |
| 241 | 156 | static TIMER_CALLBACK( ti68k_timer_callback ) |
| 242 | 157 | { |
| 243 | | t68k_state *state = machine->driver_data<t68k_state>(); |
| 158 | ti68k_state *state = machine->driver_data<ti68k_state>(); |
| 244 | 159 | static UINT64 timer; |
| 245 | 160 | |
| 246 | 161 | timer++; |
| 247 | 162 | |
| 248 | | if (state->timer_on) |
| 163 | if (state->m_timer_on) |
| 249 | 164 | { |
| 250 | | if (!(timer & state->timer_mask) && BIT(state->io_hw1[0x0a], 3)) |
| 165 | if (!(timer & state->m_timer_mask) && BIT(state->m_io_hw1[0x0a], 3)) |
| 251 | 166 | { |
| 252 | | if (state->timer_val) |
| 253 | | state->timer_val++; |
| 167 | if (state->m_timer_val) |
| 168 | state->m_timer_val++; |
| 254 | 169 | else |
| 255 | | state->timer_val = (state->io_hw1[0x0b]) & 0xff; |
| 170 | state->m_timer_val = (state->m_io_hw1[0x0b]) & 0xff; |
| 256 | 171 | } |
| 257 | 172 | |
| 258 | | if (!BIT(state->io_hw1[0x0a], 7) && ((state->hw_version == HW1) || (!BIT(state->io_hw1[0x0f], 2) && !BIT(state->io_hw1[0x0f], 1)))) |
| 173 | if (!BIT(state->m_io_hw1[0x0a], 7) && ((state->m_hw_version == state->HW1) || (!BIT(state->m_io_hw1[0x0f], 2) && !BIT(state->m_io_hw1[0x0f], 1)))) |
| 259 | 174 | { |
| 260 | 175 | if (!(timer & 0x003f)) |
| 261 | | cputag_set_input_line(machine, "maincpu", M68K_IRQ_1, HOLD_LINE); |
| 176 | state->m_maincpu->set_input_line(M68K_IRQ_1, HOLD_LINE); |
| 262 | 177 | |
| 263 | | if (!(timer & 0x3fff) && !BIT(state->io_hw1[0x0a], 3)) |
| 264 | | cputag_set_input_line(machine, "maincpu", M68K_IRQ_3, HOLD_LINE); |
| 178 | if (!(timer & 0x3fff) && !BIT(state->m_io_hw1[0x0a], 3)) |
| 179 | state->m_maincpu->set_input_line(M68K_IRQ_3, HOLD_LINE); |
| 265 | 180 | |
| 266 | | if (!(timer & state->timer_mask) && BIT(state->io_hw1[0x0a], 3) && state->timer_val == 0) |
| 267 | | cputag_set_input_line(machine, "maincpu", M68K_IRQ_5, HOLD_LINE); |
| 181 | if (!(timer & state->m_timer_mask) && BIT(state->m_io_hw1[0x0a], 3) && state->m_timer_val == 0) |
| 182 | state->m_maincpu->set_input_line(M68K_IRQ_5, HOLD_LINE); |
| 268 | 183 | } |
| 269 | 184 | } |
| 270 | 185 | |
| 271 | | if (ti_68k_keypad_r(machine) != 0xff) |
| 272 | | cputag_set_input_line(machine, "maincpu", M68K_IRQ_2, HOLD_LINE); |
| 186 | if (state->keypad_r(machine) != 0xff) |
| 187 | state->m_maincpu->set_input_line(M68K_IRQ_2, HOLD_LINE); |
| 273 | 188 | } |
| 274 | 189 | |
| 275 | 190 | |
| 276 | | static ADDRESS_MAP_START(ti92_mem, ADDRESS_SPACE_PROGRAM, 16 ) |
| 191 | static ADDRESS_MAP_START(ti92_mem, ADDRESS_SPACE_PROGRAM, 16, ti68k_state) |
| 277 | 192 | ADDRESS_MAP_UNMAP_HIGH |
| 278 | | AM_RANGE(0x000000, 0x0fffff) AM_RAM AM_BASE_SIZE_MEMBER(t68k_state, ram, ram_size) |
| 193 | AM_RANGE(0x000000, 0x0fffff) AM_RAM AM_SHARE("nvram") |
| 279 | 194 | AM_RANGE(0x200000, 0x5fffff) AM_UNMAP // ROM |
| 280 | 195 | AM_RANGE(0x600000, 0x6fffff) AM_READWRITE(ti68k_io_r, ti68k_io_w) |
| 281 | 196 | ADDRESS_MAP_END |
| 282 | 197 | |
| 283 | 198 | |
| 284 | | static ADDRESS_MAP_START(ti89_mem, ADDRESS_SPACE_PROGRAM, 16 ) |
| 199 | static ADDRESS_MAP_START(ti89_mem, ADDRESS_SPACE_PROGRAM, 16, ti68k_state) |
| 285 | 200 | ADDRESS_MAP_UNMAP_HIGH |
| 286 | | AM_RANGE(0x000000, 0x0fffff) AM_RAM AM_BASE_SIZE_MEMBER(t68k_state, ram, ram_size) |
| 287 | | AM_RANGE(0x200000, 0x3fffff) AM_READWRITE(rom_r, flash_w) |
| 201 | AM_RANGE(0x000000, 0x0fffff) AM_RAM AM_SHARE("nvram") |
| 202 | AM_RANGE(0x200000, 0x3fffff) AM_READWRITE(flash_r, flash_w) |
| 288 | 203 | AM_RANGE(0x400000, 0x5fffff) AM_NOP |
| 289 | 204 | AM_RANGE(0x600000, 0x6fffff) AM_READWRITE(ti68k_io_r, ti68k_io_w) |
| 290 | 205 | AM_RANGE(0x700000, 0x7fffff) AM_READWRITE(ti68k_io2_r, ti68k_io2_w) |
| 291 | 206 | ADDRESS_MAP_END |
| 292 | 207 | |
| 293 | 208 | |
| 294 | | static ADDRESS_MAP_START(ti92p_mem, ADDRESS_SPACE_PROGRAM, 16 ) |
| 209 | static ADDRESS_MAP_START(ti92p_mem, ADDRESS_SPACE_PROGRAM, 16, ti68k_state) |
| 295 | 210 | ADDRESS_MAP_UNMAP_HIGH |
| 296 | | AM_RANGE(0x000000, 0x0fffff) AM_RAM AM_BASE_SIZE_MEMBER(t68k_state, ram, ram_size) |
| 211 | AM_RANGE(0x000000, 0x0fffff) AM_RAM AM_SHARE("nvram") |
| 297 | 212 | AM_RANGE(0x200000, 0x3fffff) AM_NOP |
| 298 | | AM_RANGE(0x400000, 0x5fffff) AM_READWRITE(rom_r, flash_w) |
| 213 | AM_RANGE(0x400000, 0x5fffff) AM_READWRITE(flash_r, flash_w) |
| 299 | 214 | AM_RANGE(0x600000, 0x6fffff) AM_READWRITE(ti68k_io_r, ti68k_io_w) |
| 300 | 215 | AM_RANGE(0x700000, 0x7fffff) AM_READWRITE(ti68k_io2_r, ti68k_io2_w) |
| 301 | 216 | ADDRESS_MAP_END |
| 302 | 217 | |
| 303 | 218 | |
| 304 | | static ADDRESS_MAP_START(v200_mem, ADDRESS_SPACE_PROGRAM, 16 ) |
| 219 | static ADDRESS_MAP_START(v200_mem, ADDRESS_SPACE_PROGRAM, 16, ti68k_state) |
| 305 | 220 | ADDRESS_MAP_UNMAP_HIGH |
| 306 | | AM_RANGE(0x000000, 0x0fffff) AM_RAM AM_BASE_SIZE_MEMBER(t68k_state, ram, ram_size) |
| 307 | | AM_RANGE(0x200000, 0x5fffff) AM_READWRITE(rom_r, flash_w) |
| 221 | AM_RANGE(0x000000, 0x0fffff) AM_RAM AM_SHARE("nvram") |
| 222 | AM_RANGE(0x200000, 0x5fffff) AM_READWRITE(flash_r, flash_w) |
| 308 | 223 | AM_RANGE(0x600000, 0x6fffff) AM_READWRITE(ti68k_io_r, ti68k_io_w) |
| 309 | 224 | AM_RANGE(0x700000, 0x70ffff) AM_READWRITE(ti68k_io2_r, ti68k_io2_w) |
| 310 | 225 | ADDRESS_MAP_END |
| 311 | 226 | |
| 312 | 227 | |
| 313 | | static ADDRESS_MAP_START(ti89t_mem, ADDRESS_SPACE_PROGRAM, 16 ) |
| 228 | static ADDRESS_MAP_START(ti89t_mem, ADDRESS_SPACE_PROGRAM, 16, ti68k_state) |
| 314 | 229 | ADDRESS_MAP_UNMAP_HIGH |
| 315 | | AM_RANGE(0x000000, 0x0fffff) AM_RAM AM_MIRROR(0x200000) AM_BASE_SIZE_MEMBER(t68k_state, ram, ram_size) |
| 230 | AM_RANGE(0x000000, 0x0fffff) AM_RAM AM_MIRROR(0x200000) AM_SHARE("nvram") |
| 316 | 231 | AM_RANGE(0x600000, 0x6fffff) AM_READWRITE(ti68k_io_r, ti68k_io_w) |
| 317 | 232 | AM_RANGE(0x700000, 0x70ffff) AM_READWRITE(ti68k_io2_r, ti68k_io2_w) |
| 318 | | AM_RANGE(0x800000, 0xbfffff) AM_READWRITE(rom_r, flash_w) |
| 233 | AM_RANGE(0x800000, 0xbfffff) AM_READWRITE(flash_r, flash_w) |
| 319 | 234 | AM_RANGE(0xbf0000, 0xffffff) AM_NOP |
| 320 | 235 | ADDRESS_MAP_END |
| 321 | 236 | |
| 322 | 237 | |
| 323 | 238 | static INPUT_CHANGED( ti68k_on_key ) |
| 324 | 239 | { |
| 325 | | t68k_state *state = field->port->machine->driver_data<t68k_state>(); |
| 240 | ti68k_state *state = field->port->machine->driver_data<ti68k_state>(); |
| 326 | 241 | |
| 327 | | state->on_key = newval; |
| 242 | state->m_on_key = newval; |
| 328 | 243 | |
| 329 | | if (state->on_key) |
| 244 | if (state->m_on_key) |
| 330 | 245 | { |
| 331 | | if (field->port->machine->device<cpu_device>("maincpu")->suspended(SUSPEND_REASON_DISABLE)) |
| 332 | | field->port->machine->device<cpu_device>("maincpu")->resume(SUSPEND_REASON_DISABLE); |
| 246 | if (state->m_maincpu->suspended(SUSPEND_REASON_DISABLE)) |
| 247 | state->m_maincpu->resume(SUSPEND_REASON_DISABLE); |
| 333 | 248 | |
| 334 | | cputag_set_input_line(field->port->machine, "maincpu", M68K_IRQ_6, HOLD_LINE); |
| 249 | state->m_maincpu->set_input_line(M68K_IRQ_6, HOLD_LINE); |
| 335 | 250 | } |
| 336 | 251 | } |
| 337 | 252 | |
| r9621 | r9622 | |
| 346 | 261 | PORT_BIT(0x0010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("0") PORT_CODE(KEYCODE_0) |
| 347 | 262 | PORT_BIT(0x0020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("APPS") PORT_CODE(KEYCODE_F11) |
| 348 | 263 | PORT_BIT(0x0040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ESC") PORT_CODE(KEYCODE_ESC) |
| 264 | |
| 349 | 265 | PORT_START("BIT1") /* bit 1 */ |
| 350 | 266 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Left") PORT_CODE(KEYCODE_LEFT) |
| 351 | 267 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("+") PORT_CODE(KEYCODE_BACKSLASH) |
| r9621 | r9622 | |
| 354 | 270 | PORT_BIT(0x0010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("1") PORT_CODE(KEYCODE_1) |
| 355 | 271 | PORT_BIT(0x0020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("STORE") PORT_CODE(KEYCODE_TAB) |
| 356 | 272 | PORT_BIT(0x0040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ON") PORT_CODE(KEYCODE_F10) PORT_CHANGED(ti68k_on_key, 0) |
| 273 | |
| 357 | 274 | PORT_START("BIT2") /* bit 2 */ |
| 358 | 275 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Down") PORT_CODE(KEYCODE_DOWN) |
| 359 | 276 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("-") PORT_CODE(KEYCODE_MINUS) |
| r9621 | r9622 | |
| 361 | 278 | PORT_BIT(0x0008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("5") PORT_CODE(KEYCODE_5) |
| 362 | 279 | PORT_BIT(0x0010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("4") PORT_CODE(KEYCODE_4) |
| 363 | 280 | PORT_BIT(0x0020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("EE") PORT_CODE(KEYCODE_E) |
| 281 | |
| 364 | 282 | PORT_START("BIT3") /* bit 3 */ |
| 365 | 283 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Right") PORT_CODE(KEYCODE_RIGHT) |
| 366 | 284 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("*") PORT_CODE(KEYCODE_L) |
| r9621 | r9622 | |
| 368 | 286 | PORT_BIT(0x0008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("8") PORT_CODE(KEYCODE_8) |
| 369 | 287 | PORT_BIT(0x0010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("7") PORT_CODE(KEYCODE_7) |
| 370 | 288 | PORT_BIT(0x0020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("|") PORT_CODE(KEYCODE_COLON) |
| 289 | |
| 371 | 290 | PORT_START("BIT4") /* bit 4 */ |
| 372 | 291 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("2nd") PORT_CODE(KEYCODE_LALT) |
| 373 | 292 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("/") PORT_CODE(KEYCODE_SLASH) |
| r9621 | r9622 | |
| 375 | 294 | PORT_BIT(0x0008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(")") PORT_CODE(KEYCODE_CLOSEBRACE) |
| 376 | 295 | PORT_BIT(0x0010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("(") PORT_CODE(KEYCODE_OPENBRACE) |
| 377 | 296 | PORT_BIT(0x0020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("=") PORT_CODE(KEYCODE_EQUALS) |
| 297 | |
| 378 | 298 | PORT_START("BIT5") /* bit 5 */ |
| 379 | 299 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Shift") PORT_CODE(KEYCODE_LSHIFT) |
| 380 | 300 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("^") PORT_CODE(KEYCODE_P) |
| r9621 | r9622 | |
| 382 | 302 | PORT_BIT(0x0008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Z") PORT_CODE(KEYCODE_Z) |
| 383 | 303 | PORT_BIT(0x0010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Y") PORT_CODE(KEYCODE_Y) |
| 384 | 304 | PORT_BIT(0x0020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("X") PORT_CODE(KEYCODE_X) |
| 305 | |
| 385 | 306 | PORT_START("BIT6") /* bit 6 */ |
| 386 | 307 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("3nd") PORT_CODE(KEYCODE_LCONTROL) |
| 387 | 308 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CLEAR") PORT_CODE(KEYCODE_DEL) |
| r9621 | r9622 | |
| 389 | 310 | PORT_BIT(0x0008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CATALOG") PORT_CODE(KEYCODE_F8) |
| 390 | 311 | PORT_BIT(0x0010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Mode") PORT_CODE(KEYCODE_F12) |
| 391 | 312 | PORT_BIT(0x0020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("HOME") PORT_CODE(KEYCODE_HOME) |
| 313 | |
| 392 | 314 | PORT_START("BIT7") /* bit 7 */ |
| 393 | 315 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ALPHA") PORT_CODE(KEYCODE_CAPSLOCK) |
| 394 | 316 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("F5") PORT_CODE(KEYCODE_F5) |
| r9621 | r9622 | |
| 411 | 333 | PORT_BIT(0x0080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("=") PORT_CODE(KEYCODE_EQUALS) |
| 412 | 334 | PORT_BIT(0x0100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("<--") PORT_CODE(KEYCODE_BACKSPACE) |
| 413 | 335 | PORT_BIT(0x0200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("-") PORT_CODE(KEYCODE_MINUS) |
| 336 | |
| 414 | 337 | PORT_START("BIT1") /* bit 1 */ |
| 415 | 338 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("3nd") PORT_CODE(KEYCODE_LCONTROL) |
| 416 | 339 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Z") PORT_CODE(KEYCODE_Z) |
| r9621 | r9622 | |
| 422 | 345 | PORT_BIT(0x0080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("M") PORT_CODE(KEYCODE_M) |
| 423 | 346 | PORT_BIT(0x0100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("o") PORT_CODE(KEYCODE_BACKSLASH) |
| 424 | 347 | PORT_BIT(0x0200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ENTER") PORT_CODE(KEYCODE_ENTER_PAD) |
| 348 | |
| 425 | 349 | PORT_START("BIT2") /* bit 2 */ |
| 426 | 350 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Shift") PORT_CODE(KEYCODE_LSHIFT) |
| 427 | 351 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("S") PORT_CODE(KEYCODE_S) |
| r9621 | r9622 | |
| 433 | 357 | PORT_BIT(0x0080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("K") PORT_CODE(KEYCODE_K) |
| 434 | 358 | PORT_BIT(0x0100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("L") PORT_CODE(KEYCODE_L) |
| 435 | 359 | PORT_BIT(0x0200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("A") PORT_CODE(KEYCODE_A) |
| 360 | |
| 436 | 361 | PORT_START("BIT3") /* bit 3 */ |
| 437 | 362 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Clock") PORT_CODE(KEYCODE_F11) |
| 438 | 363 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("W") PORT_CODE(KEYCODE_W) |
| r9621 | r9622 | |
| 444 | 369 | PORT_BIT(0x0080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("I") PORT_CODE(KEYCODE_I) |
| 445 | 370 | PORT_BIT(0x0100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("O") PORT_CODE(KEYCODE_O) |
| 446 | 371 | PORT_BIT(0x0200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Q") PORT_CODE(KEYCODE_Q) |
| 372 | |
| 447 | 373 | PORT_START("BIT4") /* bit 4 */ |
| 448 | 374 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Left") PORT_CODE(KEYCODE_LEFT) |
| 449 | 375 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("F8") PORT_CODE(KEYCODE_F8) |
| r9621 | r9622 | |
| 455 | 381 | PORT_BIT(0x0080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("F5") PORT_CODE(KEYCODE_F5) |
| 456 | 382 | PORT_BIT(0x0100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("+") PORT_CODE(KEYCODE_PLUS_PAD) |
| 457 | 383 | PORT_BIT(0x0200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("F4") PORT_CODE(KEYCODE_F4) |
| 384 | |
| 458 | 385 | PORT_START("BIT5") /* bit 5 */ |
| 459 | 386 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Up") PORT_CODE(KEYCODE_UP) |
| 460 | 387 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("1") PORT_CODE(KEYCODE_1) |
| r9621 | r9622 | |
| 466 | 393 | PORT_BIT(0x0080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CLEAR") PORT_CODE(KEYCODE_DEL) |
| 467 | 394 | PORT_BIT(0x0100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("MODE") PORT_CODE(KEYCODE_F12) |
| 468 | 395 | PORT_BIT(0x0200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("0") PORT_CODE(KEYCODE_0) |
| 396 | |
| 469 | 397 | PORT_START("BIT6") /* bit 6 */ |
| 470 | 398 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Right") PORT_CODE(KEYCODE_RIGHT) |
| 471 | 399 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("2") PORT_CODE(KEYCODE_2) |
| r9621 | r9622 | |
| 477 | 405 | PORT_BIT(0x0080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("APPS") PORT_CODE(KEYCODE_HOME) |
| 478 | 406 | PORT_BIT(0x0100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ESC") PORT_CODE(KEYCODE_ESC) |
| 479 | 407 | PORT_BIT(0x0200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(".") PORT_CODE(KEYCODE_STOP) |
| 408 | |
| 480 | 409 | PORT_START("BIT7") /* bit 7 */ |
| 481 | 410 | PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Down") PORT_CODE(KEYCODE_DOWN) |
| 482 | 411 | PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("3") PORT_CODE(KEYCODE_3) |
| r9621 | r9622 | |
| 491 | 420 | INPUT_PORTS_END |
| 492 | 421 | |
| 493 | 422 | |
| 494 | | NVRAM_HANDLER( ti68k ) |
| 423 | void ti68k_state::machine_start() |
| 495 | 424 | { |
| 496 | | t68k_state *state = machine->driver_data<t68k_state>(); |
| 497 | | UINT16 *rom = (UINT16 *)memory_region(machine, "maincpu"); |
| 425 | UINT16 *rom = (UINT16 *)memory_region(machine, "flash"); |
| 426 | int i; |
| 498 | 427 | |
| 499 | | if (read_or_write) |
| 428 | m_flash_mem = !((rom[0x32] & 0x0f) != 0); |
| 429 | |
| 430 | if (m_flash_mem) |
| 500 | 431 | { |
| 501 | | mame_fwrite(file, state->ram, state->ram_size); |
| 432 | UINT32 base = ((((rom[0x82]) << 16) | rom[0x83]) & 0xffff)>>1; |
| 502 | 433 | |
| 503 | | /* if the memory is flash saves the content */ |
| 504 | | if (state->mem_type == FLASH) |
| 505 | | mame_fwrite(file, rom, 0x200000); |
| 434 | if (rom[base] >= 8) |
| 435 | m_hw_version = ((rom[base + 0x0b]) << 16) | rom[base + 0x0c]; |
| 436 | |
| 437 | if (!m_hw_version) |
| 438 | m_hw_version = HW1; |
| 439 | |
| 440 | for (i = 0x9000; i < 0x100000; i++) |
| 441 | if (rom[i] == 0xcccc && rom[i + 1] == 0xcccc) |
| 442 | break; |
| 443 | |
| 444 | m_initial_pc = ((rom[i + 4]) << 16) | rom[i + 5]; |
| 506 | 445 | } |
| 507 | 446 | else |
| 508 | 447 | { |
| 509 | | if (file) |
| 448 | m_hw_version = HW1; |
| 449 | m_initial_pc = ((rom[2]) << 16) | rom[3]; |
| 450 | |
| 451 | memory_unmap_read(m_maincpu->space(ADDRESS_SPACE_PROGRAM), 0x200000, 0x5fffff, 0, 0); |
| 452 | |
| 453 | if (m_initial_pc > 0x400000) |
| 510 | 454 | { |
| 511 | | mame_fread(file, state->ram, state->ram_size); |
| 512 | | if (state->mem_type == FLASH) |
| 513 | | mame_fread(file, rom, 0x200000); |
| 455 | m_maincpu->space(ADDRESS_SPACE_PROGRAM)->install_handler(0x400000, 0x5fffff, 0, 0, read16_delegate_create(ti68k_state, flash_r, *this)); |
| 456 | m_maincpu->space(ADDRESS_SPACE_PROGRAM)->install_handler(0x400000, 0x5fffff, 0, 0, write16_delegate_create(ti68k_state, flash_w, *this)); |
| 514 | 457 | } |
| 515 | | else |
| 516 | | memset(state->ram, 0, sizeof(state->ram)); |
| 458 | else |
| 459 | { |
| 460 | m_maincpu->space(ADDRESS_SPACE_PROGRAM)->install_handler(0x200000, 0x3fffff, 0, 0, read16_delegate_create(ti68k_state, flash_r, *this)); |
| 461 | m_maincpu->space(ADDRESS_SPACE_PROGRAM)->install_handler(0x200000, 0x3fffff, 0, 0, write16_delegate_create(ti68k_state, flash_w, *this)); |
| 462 | } |
| 517 | 463 | } |
| 518 | | } |
| 519 | 464 | |
| 465 | timer_pulse(machine, ATTOTIME_IN_HZ(1<<14), NULL, 0, ti68k_timer_callback); |
| 520 | 466 | |
| 521 | | static MACHINE_RESET(ti68k) |
| 522 | | { |
| 523 | | t68k_state *state = machine->driver_data<t68k_state>(); |
| 524 | | cpu_set_reg(machine->device("maincpu"), M68K_PC, state->initial_pc); |
| 525 | | |
| 526 | | state->kb_mask = 0xff; |
| 527 | | state->on_key = 0; |
| 528 | | state->lcd_base = 0; |
| 529 | | state->lcd_width = 0; |
| 530 | | state->lcd_height = 0; |
| 531 | | state->lcd_on = 0; |
| 532 | | state->lcd_contrast = 0; |
| 533 | | state->flash_protect = 0; |
| 534 | | state->flash_state = 0; |
| 535 | | state->flash_wait = 0; |
| 536 | | state->flash_ready = 0; |
| 537 | | memset(state->io_hw1, 0, sizeof(state->io_hw1)); |
| 538 | | memset(state->io_hw2, 0, sizeof(state->io_hw2)); |
| 539 | | state->timer_on = 0; |
| 540 | | state->timer_mask = 0xf; |
| 541 | | state->timer_val = 0; |
| 467 | logerror("HW=v%x, PC=%06x, Type=%s\n", m_hw_version, m_initial_pc, (m_flash_mem) ? "Flash" : "ROM"); |
| 542 | 468 | } |
| 543 | 469 | |
| 544 | | /* video */ |
| 545 | 470 | |
| 546 | | static VIDEO_START( ti68k ) |
| 471 | void ti68k_state::machine_reset() |
| 547 | 472 | { |
| 473 | m_maincpu->set_state(M68K_PC, m_initial_pc); |
| 548 | 474 | |
| 475 | m_kb_mask = 0xff; |
| 476 | m_on_key = 0; |
| 477 | m_lcd_base = 0; |
| 478 | m_lcd_width = 0; |
| 479 | m_lcd_height = 0; |
| 480 | m_lcd_on = 0; |
| 481 | m_lcd_contrast = 0; |
| 482 | memset(m_io_hw1, 0, ARRAY_LENGTH(m_io_hw1) * sizeof(UINT16)); |
| 483 | memset(m_io_hw2, 0, ARRAY_LENGTH(m_io_hw2) * sizeof(UINT16)); |
| 484 | m_timer_on = 0; |
| 485 | m_timer_mask = 0xf; |
| 486 | m_timer_val = 0; |
| 549 | 487 | } |
| 550 | 488 | |
| 551 | | static VIDEO_UPDATE( ti68k ) |
| 489 | /* video */ |
| 490 | bool ti68k_state::video_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect) |
| 552 | 491 | { |
| 553 | 492 | /* preliminary implementation, doesn't use the contrast value */ |
| 554 | | t68k_state *state = screen->machine->driver_data<t68k_state>(); |
| 555 | | address_space *space = cputag_get_address_space(screen->machine, "maincpu", ADDRESS_SPACE_PROGRAM); |
| 556 | | UINT8 width = screen->width(); |
| 557 | | UINT8 height = screen->height(); |
| 493 | UINT8 width = screen.width(); |
| 494 | UINT8 height = screen.height(); |
| 558 | 495 | UINT8 x, y, b; |
| 559 | 496 | |
| 560 | | if (!state->lcd_on || !state->lcd_base) |
| 561 | | bitmap_fill(bitmap, NULL, 1); |
| 497 | if (!m_lcd_on || !m_lcd_base) |
| 498 | bitmap_fill(&bitmap, NULL, 0); |
| 562 | 499 | else |
| 563 | 500 | for (y = 0; y < height; y++) |
| 564 | 501 | for (x = 0; x < width / 8; x++) |
| 565 | 502 | { |
| 566 | | UINT8 s_byte= space->read_byte(state->lcd_base + y * (width/8) + x); |
| 503 | UINT8 s_byte= m_maincpu->space(ADDRESS_SPACE_PROGRAM)->read_byte(m_lcd_base + y * (width/8) + x); |
| 567 | 504 | for (b = 0; b<8; b++) |
| 568 | | *BITMAP_ADDR16(bitmap, y, x * 8 + (7 - b)) = (BIT(s_byte, b) > 0) ? 0 : 1; |
| 505 | *BITMAP_ADDR16(&bitmap, y, x * 8 + (7 - b)) = BIT(s_byte, b); |
| 569 | 506 | } |
| 570 | 507 | |
| 571 | 508 | return 0; |
| 572 | 509 | } |
| 573 | 510 | |
| 574 | | |
| 575 | | MACHINE_START( ti68k ) |
| 511 | static PALETTE_INIT( ti68k ) |
| 576 | 512 | { |
| 577 | | t68k_state *state = machine->driver_data<t68k_state>(); |
| 578 | | address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM); |
| 579 | | UINT16 *rom = (UINT16 *)memory_region(space->machine, "maincpu"); |
| 580 | | int i; |
| 581 | | |
| 582 | | state->mem_type= (rom[0x32] & 0x0f) ? EPROM : FLASH; |
| 583 | | |
| 584 | | if (state->mem_type == FLASH) |
| 585 | | { |
| 586 | | UINT32 base = ((((rom[0x82]) << 16) | rom[0x83]) & 0xffff)>>1; |
| 587 | | |
| 588 | | if (rom[base] >= 8) |
| 589 | | state->hw_version = ((rom[base + 0x0b]) << 16) | rom[base + 0x0c]; |
| 590 | | |
| 591 | | if (!state->hw_version) |
| 592 | | state->hw_version = HW1; |
| 593 | | |
| 594 | | for (i = 0x9000; i < 0x100000; i++) |
| 595 | | if (rom[i] == 0xcccc && rom[i + 1] == 0xcccc) |
| 596 | | break; |
| 597 | | |
| 598 | | state->initial_pc = ((rom[i + 4]) << 16) | rom[i + 5]; |
| 599 | | } |
| 600 | | else |
| 601 | | { |
| 602 | | state->hw_version = HW1; |
| 603 | | state->initial_pc = ((rom[2]) << 16) | rom[3]; |
| 604 | | |
| 605 | | memory_unmap_read(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), 0x200000, 0x5fffff, 0, 0); |
| 606 | | |
| 607 | | if (state->initial_pc > 0x400000) |
| 608 | | memory_install_read16_handler( cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), 0x400000, 0x5fffff, 0, 0, rom_r ); |
| 609 | | else |
| 610 | | memory_install_read16_handler( cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), 0x200000, 0x3fffff, 0, 0, rom_r ); |
| 611 | | |
| 612 | | } |
| 613 | | |
| 614 | | timer_pulse(machine, ATTOTIME_IN_HZ(1<<14), NULL, 0, ti68k_timer_callback); |
| 513 | palette_set_color(machine, 0, MAKE_RGB(138, 146, 148)); |
| 514 | palette_set_color(machine, 1, MAKE_RGB(92, 83, 88)); |
| 615 | 515 | } |
| 616 | 516 | |
| 617 | | |
| 618 | | static MACHINE_CONFIG_START( ti89, t68k_state ) |
| 619 | | |
| 517 | static MACHINE_CONFIG_START( ti89, ti68k_state ) |
| 620 | 518 | /* basic machine hardware */ |
| 621 | | MDRV_CPU_ADD("maincpu",M68000, XTAL_10MHz) |
| 519 | MDRV_CPU_ADD("maincpu", M68000, XTAL_10MHz) |
| 622 | 520 | MDRV_CPU_PROGRAM_MAP(ti89_mem) |
| 623 | 521 | |
| 624 | | MDRV_MACHINE_RESET(ti68k) |
| 522 | MDRV_NVRAM_ADD_0FILL("nvram") |
| 625 | 523 | |
| 626 | 524 | /* video hardware */ |
| 627 | 525 | MDRV_SCREEN_ADD("screen", RASTER) |
| r9621 | r9622 | |
| 631 | 529 | MDRV_SCREEN_SIZE(240, 128) |
| 632 | 530 | MDRV_SCREEN_VISIBLE_AREA(0, 160-1, 0, 100-1) |
| 633 | 531 | MDRV_PALETTE_LENGTH(2) |
| 532 | MDRV_PALETTE_INIT(ti68k) |
| 634 | 533 | MDRV_DEFAULT_LAYOUT(layout_lcd) |
| 635 | | MDRV_PALETTE_INIT(black_and_white) |
| 636 | 534 | |
| 637 | | MDRV_VIDEO_START(ti68k) |
| 638 | | MDRV_VIDEO_UPDATE(ti68k) |
| 639 | | |
| 640 | | MDRV_MACHINE_START( ti68k ) |
| 641 | | |
| 642 | | MDRV_NVRAM_HANDLER(ti68k) |
| 643 | | |
| 535 | MDRV_SHARP_UNK128MBIT_ADD("flash") //should be LH28F320 for ti89t and v200 and LH28F160S3T for other models |
| 644 | 536 | MACHINE_CONFIG_END |
| 645 | 537 | |
| 646 | 538 | |
| 647 | 539 | static MACHINE_CONFIG_DERIVED( ti92, ti89 ) |
| 648 | | |
| 649 | 540 | MDRV_CPU_MODIFY("maincpu") |
| 650 | 541 | MDRV_CPU_PROGRAM_MAP(ti92_mem) |
| 651 | 542 | |
| 652 | 543 | /* video hardware */ |
| 653 | 544 | MDRV_SCREEN_MODIFY("screen") |
| 654 | 545 | MDRV_SCREEN_VISIBLE_AREA(0, 240-1, 0, 128-1) |
| 655 | | |
| 656 | | |
| 657 | 546 | MACHINE_CONFIG_END |
| 658 | 547 | |
| 659 | 548 | |
| 660 | | static MACHINE_CONFIG_DERIVED( ti92p, ti89 ) |
| 661 | | |
| 662 | | MDRV_CPU_REPLACE("maincpu",M68000, XTAL_12MHz) |
| 549 | static MACHINE_CONFIG_DERIVED( ti92p, ti92 ) |
| 550 | MDRV_CPU_REPLACE("maincpu", M68000, XTAL_12MHz) |
| 663 | 551 | MDRV_CPU_PROGRAM_MAP(ti92p_mem) |
| 664 | | |
| 665 | | /* video hardware */ |
| 666 | | MDRV_SCREEN_MODIFY("screen") |
| 667 | | MDRV_SCREEN_VISIBLE_AREA(0, 240-1, 0, 128-1) |
| 668 | | |
| 669 | 552 | MACHINE_CONFIG_END |
| 670 | 553 | |
| 671 | 554 | |
| 672 | | static MACHINE_CONFIG_DERIVED( v200, ti89 ) |
| 673 | | |
| 674 | | MDRV_CPU_REPLACE("maincpu",M68000, XTAL_12MHz) |
| 555 | static MACHINE_CONFIG_DERIVED( v200, ti92 ) |
| 556 | MDRV_CPU_REPLACE("maincpu", M68000, XTAL_12MHz) |
| 675 | 557 | MDRV_CPU_PROGRAM_MAP(v200_mem) |
| 676 | | |
| 677 | | /* video hardware */ |
| 678 | | MDRV_SCREEN_MODIFY("screen") |
| 679 | | MDRV_SCREEN_VISIBLE_AREA(0, 240-1, 0, 128-1) |
| 680 | | |
| 681 | 558 | MACHINE_CONFIG_END |
| 682 | 559 | |
| 683 | 560 | |
| 684 | 561 | static MACHINE_CONFIG_DERIVED( ti89t, ti89 ) |
| 685 | | |
| 686 | | MDRV_CPU_REPLACE("maincpu",M68000, XTAL_16MHz) |
| 562 | MDRV_CPU_REPLACE("maincpu", M68000, XTAL_16MHz) |
| 687 | 563 | MDRV_CPU_PROGRAM_MAP(ti89t_mem) |
| 688 | | |
| 689 | 564 | MACHINE_CONFIG_END |
| 690 | 565 | |
| 691 | 566 | |
| 692 | 567 | /* ROM definition */ |
| 693 | 568 | ROM_START( ti89 ) |
| 694 | | ROM_REGION( 0x200000, "maincpu", ROMREGION_ERASEFF ) |
| 569 | ROM_REGION( 0x200000, "flash", ROMREGION_ERASEFF ) |
| 695 | 570 | ROM_SYSTEM_BIOS( 0, "v100", "V 1.00 - HW1" ) |
| 696 | 571 | ROMX_LOAD( "ti89v100.rom", 0x000000, 0x200000, CRC(264b34ad) SHA1(c87586a7e9b6d49fbe908fbb6f3c0038f3498573), ROM_BIOS(1)) |
| 697 | 572 | ROM_SYSTEM_BIOS( 1, "v100a", "V 1.00 [a] - HW1" ) |
| r9621 | r9622 | |
| 727 | 602 | ROM_END |
| 728 | 603 | |
| 729 | 604 | ROM_START( ti92 ) |
| 730 | | ROM_REGION( 0x200000, "maincpu", ROMREGION_ERASEFF ) |
| 605 | ROM_REGION( 0x200000, "flash", ROMREGION_ERASEFF ) |
| 731 | 606 | ROM_SYSTEM_BIOS( 0, "v111", "V 1.11" ) |
| 732 | 607 | ROMX_LOAD( "ti92v111.rom", 0x000000, 0x100000, CRC(67878d52) SHA1(c0fdf162961922a76f286c93fd9b861ce20f23a3), ROM_BIOS(1)) |
| 733 | 608 | ROM_SYSTEM_BIOS( 1, "v13", "V 1.3" ) |
| r9621 | r9622 | |
| 746 | 621 | ROM_END |
| 747 | 622 | |
| 748 | 623 | ROM_START( ti92p ) |
| 749 | | ROM_REGION( 0x200000, "maincpu", ROMREGION_ERASEFF ) |
| 624 | ROM_REGION( 0x200000, "flash", ROMREGION_ERASEFF ) |
| 750 | 625 | ROM_SYSTEM_BIOS( 0, "v100", "V 1.00 - HW1" ) |
| 751 | 626 | ROMX_LOAD( "ti92pv100.rom", 0x0000, 0x200000, CRC(c651a586) SHA1(fbbf7e053e70eefe517f9aae40c072036bc614ea), ROM_BIOS(1)) |
| 752 | 627 | ROM_SYSTEM_BIOS( 1, "v101", "V 1.01 - HW1" ) |
| r9621 | r9622 | |
| 772 | 647 | ROM_END |
| 773 | 648 | |
| 774 | 649 | ROM_START( v200 ) |
| 775 | | ROM_REGION( 0x400000, "maincpu", ROMREGION_ERASEFF ) |
| 650 | ROM_REGION( 0x400000, "flash", ROMREGION_ERASEFF ) |
| 776 | 651 | ROM_SYSTEM_BIOS( 0, "v209", "V 2.09" ) |
| 777 | 652 | ROMX_LOAD( "voyage200v209.rom", 0x0000, 0x400000, CRC(f805c7a6) SHA1(818b919058ba3bd7d15604f11fff6740010d07fc), ROM_BIOS(1)) |
| 778 | 653 | ROM_SYSTEM_BIOS( 1, "v310", "V 3.10" ) |
| r9621 | r9622 | |
| 780 | 655 | ROM_END |
| 781 | 656 | |
| 782 | 657 | ROM_START( ti89t ) |
| 783 | | ROM_REGION( 0x400000, "maincpu", ROMREGION_ERASEFF ) |
| 658 | ROM_REGION( 0x400000, "flash", ROMREGION_ERASEFF ) |
| 784 | 659 | ROM_SYSTEM_BIOS( 0, "v300", "V 3.00" ) |
| 785 | 660 | ROMX_LOAD( "ti89tv300.rom", 0x0000, 0x400000, CRC(55eb4f5a) SHA1(4f919d7752caf2559a79883ec8711a9701d19513), ROM_BIOS(1)) |
| 786 | 661 | ROM_SYSTEM_BIOS( 1, "v310", "V 3.10" ) |